IA & Data science (LU3IN0226) -- 2024-2025¶
© Equipe pédagogique: Christophe Marsala, Olivier Schwander, Jean-Noël Vittaut.
Mini-projet final¶
[Q] Indiquer dans la boîte ci-dessous vos noms et prénoms :
Yuxiang ZHANG & Antoine LECOMTE
Ce projet peut être fait en binôme (et c'est fortement conseillé) ou tout seul.
Le nom de chaque membre du binôme doit être indiqué, et un seul rendu sur un des deux comptes Moodle doit être fait.
Les groupes de plus de 2 personnes ne sont pas autorisés.
La dernière séance de TD-TME11 de votre groupe sera réservée pour travailler sur ce mini-projet.
[Q] Renommer ce fichier ipython
Nom à donner au fichier à poster : projet-Nom1_Nom2.ipynb
- Nom1 et Nom2 : noms des membres du binôme
- ne pas compresser ou faire une archive: il faut rendre le fichier ipython tel quel, éventuellement, si vous avez d'autres fichiers vous les rendez séparément.
Le compte-rendu est soumis sur la page Moodle.
Projet 2 - avril-mai 2025¶
Date de rendu : au plus tard le lundi 19 mai 2025, avant 11h
Attention! le site Moodle ferme à 11h pile ! prévoyez de vous y connecter au moins 15mn avant la fermeture... Il n'y aura pas de prolongation possible.
Vous devez compléter ce notebook en rajoutant vos expérimentations avec vos algorithmes d'apprentissage sur les données fournies dans le répertoire data.
Travail à faire¶
Appliquer les algorithmes d'apprentissage vus en cours sur les données comme décrit ci-dessous afin de mettre en évidence des résultats intéressants.
Compte-rendu demandé¶
Ce qui doit être remis avant la date limite : un fichier archive (.tar, .tgz, ou .zip uniquement) contenant:
- ce notebook complété. Il doit pouvoir être exécuté sans autre apport (pensez à vous en assurer avant de le rendre).
- votre librairie iads sous la forme d'une archive avec votre répertoire
iads/contenant tous les fichiers nécessaires - un poster sous la forme d'un fichier PDF dont le nom est de la forme: tme11-Nom1_Nom2.pdf qui correspond à un poster décrivant l'ensemble des expérimentations menées et les résultats obtenus.
IMPORTANT:
- Les fichiers de données ne doivent pas être inclus dans votre archive !
- Pensez à vérifier que votre archive contient bien tous les fichiers demandés et seulement les fichiers demandés.
- **Tous les fichiers demandés doivent être soumis avant la date limite*, le jour de la soutenance, vous pourrez fournir des versions (légèrement) modifiées.
Soutenance des projets¶
La soutenance aura lieu le mardi 20 mai 2025, à partir de 9h. Un ordre de passage ainsi que la salle de TME où aura lieu les soutenances seront affichées sur le Moodle la veille (la remise d'un compte-rendu avant lundi 19 mai 11h est obligatoire pour être autorisé à passer une soutenance).
La soutenance est obligatoire : tout projet pour lequel une soutenance n'a pas eu lieu sera noté $0$.
Modalités de la soutenance:
- durée de la soutenance : 10 mn pour un binôme, 7 mn pour un monôme ;
- elle a lieu devant un ordinateur avec le notebook et le poster comme support ;
- elle commence par une rapide présentation des expérimentations réalisées et résultats obtenus (max. 4 à 5mns)
- puis elle se poursuit par des questions posées individuellement aux membres du binômes sur les expériences ou le code python réalisé.
- la note de soutenance est individuelle pour chaque membre d'un binôme.
Très important : les fichiers de données doivent être placés de façon à respecter la structure de fichiers suivante :
--iads/
-- Classifiers.py
-- etc.
-- MiniProjet/
-- ce_notebook.ipynb
Les données seront chargées par les commandes de chargement des données fournies dans ce notebook (ci-dessous).
Dans le notebook que vous rendrez, le chargement des fichiers de données doit considérer cette arborescence.
# Importation de librairies standards:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
# un nouvel import utile pour la 3D:
from matplotlib import cm
# Les instructions suivantes sont TRES utiles pour recharger automatiquement
# le code modifié dans les librairies externes
%load_ext autoreload
%autoreload 2
# Pour mesurer le temps
import time
# Importation de votre librairie iads:
# La ligne suivante permet de préciser le chemin d'accès à la librairie iads
import sys
sys.path.append('../') # iads doit être dans le répertoire père du répertoire courant !
# Importation de la librairie iads
import iads as iads
# importation de Classifiers
from iads import Classifiers as classif
# importation de utils
from iads import utils as ut
# importation de evaluation
from iads import evaluation as ev
# importation de Clustering
from iads import Clustering as clust
# commande TRES utile pour recharger automatiquement le code que vous modifiez dans les modules
%load_ext autoreload
%autoreload 2
import math
from scipy.sparse import csr_matrix
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics.pairwise import cosine_distances
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, ConfusionMatrixDisplay
from sklearn.model_selection import cross_val_score, StratifiedKFold
from sklearn.metrics import silhouette_score
from sklearn.metrics import adjusted_rand_score, normalized_mutual_info_score
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.decomposition import PCA
import graphviz as gv
The autoreload extension is already loaded. To reload it, use: %reload_ext autoreload The autoreload extension is already loaded. To reload it, use: %reload_ext autoreload
"Dans le cadre de notre projet de machine learning sur 20newsgroups, nous avons rencontré d'importantes difficultés de performance avec nos classifieurs personnalisés, qui se révélaient trop lents et provoquaient fréquemment des plantages du noyau. Sur les conseils de ChatGPT, nous avons opté pour une série de bibliothèques Python optimisées : scipy.sparse pour la gestion efficace des matrices creuses, plusieurs classifieurs de scikit-learn comme KNeighborsClassifier et DecisionTreeClassifier, ainsi que des outils de vectorisation de texte (CountVectorizer) et de réduction de dimension (PCA). Nous avons également intégré des métriques d'évaluation complètes (accuracy_score, confusion_matrix) et des méthodes de validation croisée pour éviter le surapprentissage. Ces solutions nous ont permis de résoudre nos problèmes initiaux tout en optimisant significativement les performances de notre système, notamment grâce aux implémentations optimisées de scikit-learn pour le traitement multiclasse et à la gestion mémoire efficace des structures de données creuses."
Données pour le projet : 20newsgroups¶
Les données sont fournies dans le fichier CSV 20newsgroups.csv contenu dans l'archive. Une documentation sur ces données peut être consultée sur la page ScikitLearn.
Ces données sont des dépêches issues de 20 groupes de discussions.
Chargement des données¶
newsgroups_df = pd.read_csv("data/20newsgroups.csv")
newsgroups_df
| messages | target | |
|---|---|---|
| 0 | \n\nI am sure some bashers of Pens fans are pr... | 10 |
| 1 | My brother is in the market for a high-perform... | 3 |
| 2 | \n\n\n\n\tFinally you said what you dream abou... | 17 |
| 3 | \nThink!\n\nIt's the SCSI card doing the DMA t... | 3 |
| 4 | 1) I have an old Jasmine drive which I cann... | 4 |
| ... | ... | ... |
| 18841 | DN> From: nyeda@cnsvax.uwec.edu (David Nye)\nD... | 13 |
| 18842 | \nNot in isolated ground recepticles (usually ... | 12 |
| 18843 | I just installed a DX2-66 CPU in a clone mothe... | 3 |
| 18844 | \nWouldn't this require a hyper-sphere. In 3-... | 1 |
| 18845 | After a tip from Gary Crum (crum@fcom.cc.utah.... | 7 |
18846 rows × 2 columns
Prétraitement¶
Dans un premier temps, vous devez appliquer les étapes de prétraitements vues dans le TME 6. Pour le nettoyage, la liste des mots inutiles (stopwords) est fournie dans le fichier stopwords.csv de l'archive
stop_words_df = pd.read_csv("data/stopwords.csv")
stop_words_df
| stopword | |
|---|---|
| 0 | a |
| 1 | about |
| 2 | above |
| 3 | after |
| 4 | again |
| ... | ... |
| 193 | you're |
| 194 | yours |
| 195 | yourself |
| 196 | yourselves |
| 197 | you've |
198 rows × 1 columns
newsgroups_df_neitoie = newsgroups_df.dropna(subset=['messages'])
stop_words_list = stop_words_df['stopword'].tolist()
newsgroups_df_neitoie['les_mots'] = newsgroups_df_neitoie['messages'].apply(lambda x: ut.text2vect(x, stop_words_list))
newsgroups_df_neitoie
/var/folders/x0/9jmwqqtj7s13pdfprxbhp6r00000gn/T/ipykernel_47223/959504396.py:3: SettingWithCopyWarning: A value is trying to be set on a copy of a slice from a DataFrame. Try using .loc[row_indexer,col_indexer] = value instead See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy newsgroups_df_neitoie['les_mots'] = newsgroups_df_neitoie['messages'].apply(lambda x: ut.text2vect(x, stop_words_list))
| messages | target | les_mots | |
|---|---|---|---|
| 0 | \n\nI am sure some bashers of Pens fans are pr... | 10 | [sure, bashers, pens, fans, pretty, confused, ... |
| 1 | My brother is in the market for a high-perform... | 3 | [brother, market, high, performance, video, ca... |
| 2 | \n\n\n\n\tFinally you said what you dream abou... | 17 | [finally, said, dream, mediterranean, new, are... |
| 3 | \nThink!\n\nIt's the SCSI card doing the DMA t... | 3 | [think, scsi, card, dma, transfers, disks, scs... |
| 4 | 1) I have an old Jasmine drive which I cann... | 4 | [old, jasmine, drive, cannot, use, new, system... |
| ... | ... | ... | ... |
| 18841 | DN> From: nyeda@cnsvax.uwec.edu (David Nye)\nD... | 13 | [dn, nyeda, cnsvax, uwec, edu, david, nye, dn,... |
| 18842 | \nNot in isolated ground recepticles (usually ... | 12 | [isolated, ground, recepticles, usually, unusu... |
| 18843 | I just installed a DX2-66 CPU in a clone mothe... | 3 | [installed, cpu, clone, motherboard, tried, mo... |
| 18844 | \nWouldn't this require a hyper-sphere. In 3-... | 1 | [require, hyper, sphere, space, points, specif... |
| 18845 | After a tip from Gary Crum (crum@fcom.cc.utah.... | 7 | [tip, gary, crum, crum, fcom, cc, utah, edu, g... |
18466 rows × 3 columns
index_mots = sorted(set(word for mots in newsgroups_df_neitoie['les_mots'] for word in mots))
print("Nombre de mots trouvés: ", len(index_mots))
print("Les 10 premiers :", index_mots[0:10])
# pour contrôler:
for i in range(30,len(index_mots),100):
print("\ten position ",i," --> ", index_mots[i])
Nombre de mots trouvés: 90850 Les 10 premiers : ["''a", "''achzq", "''afduqy", "''afg", "''ai", "''ai''q", "''al", "''bpl", "''bs", "''c"] en position 30 --> 'afdzqvg'al en position 130 --> 'i' en position 230 --> 'qp en position 330 --> 'wx en position 430 --> aarskog en position 530 --> abhorrence en position 630 --> abridgement en position 730 --> acadamy en position 830 --> accom en position 930 --> accusers en position 1030 --> acknowledgment en position 1130 --> activitiests en position 1230 --> adda en position 1330 --> aditives en position 1430 --> ado en position 1530 --> adventists en position 1630 --> aerodynamics en position 1730 --> afflicting en position 1830 --> agabus en position 1930 --> agonies en position 2030 --> ahmad en position 2130 --> aire en position 2230 --> ajteel en position 2330 --> alarm en position 2430 --> aleuts en position 2530 --> alive en position 2630 --> allowances en position 2730 --> alsys en position 2830 --> amanda en position 2930 --> amfar en position 3030 --> amphetamines en position 3130 --> analgesics en position 3230 --> anders en position 3330 --> angles en position 3430 --> annihiliation en position 3530 --> anpv en position 3630 --> antidote en position 3730 --> anybodys en position 3830 --> apcut en position 3930 --> appaddinput en position 4030 --> applikation en position 4130 --> approximately en position 4230 --> arabie en position 4330 --> archive en position 4430 --> argv en position 4530 --> armenia en position 4630 --> arraymax en position 4730 --> artifact en position 4830 --> ase en position 4930 --> aspersions en position 5030 --> assign en position 5130 --> astounded en position 5230 --> atary en position 5330 --> atni en position 5430 --> attitute en position 5530 --> auggggg en position 5630 --> authers en position 5730 --> automotive en position 5830 --> aversion en position 5930 --> awfully en position 6030 --> aything en position 6130 --> ba'als en position 6230 --> backlighting en position 6330 --> baf en position 6430 --> baldschun en position 6530 --> bandits en position 6630 --> barbequing en position 6730 --> barrettd en position 6830 --> basicaly en position 6930 --> battleship en position 7030 --> bcg'x en position 7130 --> bearded en position 7230 --> bedouin's en position 7330 --> begzadian en position 7430 --> belies en position 7530 --> bendi en position 7630 --> bereft en position 7730 --> besler en position 7830 --> bfoffbits en position 7930 --> bi'g en position 8030 --> bigmac en position 8130 --> bimidgi en position 8230 --> biotechnet en position 8330 --> bitsy en position 8430 --> blacklists en position 8530 --> ble en position 8630 --> blocks en position 8730 --> blur en position 8830 --> boaring en position 8930 --> boilers en position 9030 --> bonilla's en position 9130 --> bootup en position 9230 --> bosse en position 9330 --> bowers en position 9430 --> brace en position 9530 --> bratt en position 9630 --> breezed en position 9730 --> brighter en position 9830 --> broken en position 9930 --> brulliance en position 10030 --> btw en position 10130 --> buffeting en position 10230 --> bullied en position 10330 --> bure's en position 10430 --> buses en position 10530 --> bux en position 10630 --> bymmr en position 10730 --> cabinetmaker en position 10830 --> calander en position 10930 --> callsign en position 11030 --> campollo en position 11130 --> cannon en position 11230 --> capped en position 11330 --> cardfile en position 11430 --> caroline en position 11530 --> case en position 11630 --> catcat en position 11730 --> cavallini en position 11830 --> ccelum en position 11930 --> ceasing en position 12030 --> census en position 12130 --> cert en position 12230 --> cgin en position 12330 --> championships en position 12430 --> charged en position 12530 --> cheapish en position 12630 --> cheney en position 12730 --> chigger en position 12830 --> chistmas en position 12930 --> chow en position 13030 --> chronological en position 13130 --> ciau en position 13230 --> circ en position 13330 --> citr en position 13430 --> clam en position 13530 --> clay en position 13630 --> clia en position 13730 --> clling en position 13830 --> clumsy en position 13930 --> cnql en position 14030 --> cocktails en position 14130 --> coiled en position 14230 --> collectors en position 14330 --> colortable en position 14430 --> comet en position 14530 --> commericalization en position 14630 --> community's en position 14730 --> compete en position 14830 --> composed en position 14930 --> computerist en position 15030 --> concise en position 15130 --> conductor en position 15230 --> conforming en position 15330 --> conklin en position 15430 --> consent en position 15530 --> constable en position 15630 --> contacting en position 15730 --> contool en position 15830 --> conuntry en position 15930 --> cook en position 16030 --> coprocessors en position 16130 --> cornering en position 16230 --> corse en position 16330 --> coul en position 16430 --> courageous en position 16530 --> cowl en position 16630 --> craetveld en position 16730 --> creased en position 16830 --> criminalization en position 16930 --> crock en position 17030 --> crres en position 17130 --> cryptanalysis en position 17230 --> csri en position 17330 --> cuddles en position 17430 --> curcio en position 17530 --> cutaway en position 17630 --> cxtgcxwocxxi en position 17730 --> cyprian en position 17830 --> dabro en position 17930 --> daly en position 18030 --> dante en position 18130 --> dastar en position 18230 --> davidsson's en position 18330 --> dcdmwm en position 18430 --> deals en position 18530 --> deceitfulness en position 18630 --> decompose en position 18730 --> deducible en position 18830 --> defensible en position 18930 --> defused en position 19030 --> delegate en position 19130 --> delve en position 19230 --> demosrc en position 19330 --> deny en position 19430 --> depresses en position 19530 --> desciption en position 19630 --> desnoyers en position 19730 --> detaining en position 19830 --> deuterocanonical en position 19930 --> dew en position 20030 --> di en position 20130 --> dick en position 20230 --> differ en position 20330 --> diku en position 20430 --> diocese en position 20530 --> dis en position 20630 --> discharged en position 20730 --> discriminated en position 20830 --> disire en position 20930 --> dispelling en position 21030 --> dissapated en position 21130 --> distributer en position 21230 --> division's en position 21330 --> dli en position 21430 --> docialists en position 21530 --> dogskin en position 21630 --> donestr en position 21730 --> dos en position 21830 --> downlink en position 21930 --> draft en position 22030 --> dremel en position 22130 --> drosophila en position 22230 --> dss en position 22330 --> dudley en position 22430 --> dunn en position 22530 --> dvhz en position 22630 --> dylan en position 22730 --> earliest en position 22830 --> eberle en position 22930 --> ecnet en position 23030 --> edited en position 23130 --> eerie en position 23230 --> egg en position 23330 --> eighth en position 23430 --> elaborates en position 23530 --> electrophotography en position 23630 --> ellernstr en position 23730 --> emailed en position 23830 --> emersing en position 23930 --> empirically en position 24030 --> enchanter en position 24130 --> endeth en position 24230 --> engine's en position 24330 --> enrich en position 24430 --> entranced en position 24530 --> eo en position 24630 --> eprom en position 24730 --> eradicators en position 24830 --> eroticism en position 24930 --> escherknot en position 25030 --> essensa en position 25130 --> etherfind en position 25230 --> euh en position 25330 --> evangelist en position 25430 --> evident en position 25530 --> exactly en position 25630 --> exchanger en position 25730 --> exempting en position 25830 --> exothermic en position 25930 --> expiration en position 26030 --> expressway en position 26130 --> extravaganza en position 26230 --> ezqiv en position 26330 --> factorization en position 26430 --> faithlessly en position 26530 --> fan's en position 26630 --> farringdon en position 26730 --> faulkt en position 26830 --> fcv en position 26930 --> federation en position 27030 --> felsner en position 27130 --> fertilization en position 27230 --> fgj en position 27330 --> fields en position 27430 --> fileserver en position 27530 --> fingers en position 27630 --> firsthand en position 27730 --> fjp en position 27830 --> flashlight en position 27930 --> flibozity en position 28030 --> florescent en position 28130 --> fm en position 28230 --> foiidfkx en position 28330 --> fools en position 28430 --> foremost en position 28530 --> formicinae en position 28630 --> fossils en position 28730 --> fpus en position 28830 --> francisco en position 28930 --> freemasons en position 29030 --> fries en position 29130 --> frr en position 29230 --> ftpmail en position 29330 --> fullness en position 29430 --> furleys en position 29530 --> fwmr en position 29630 --> g'ors en position 29730 --> galiatsato en position 29830 --> gangbusters en position 29930 --> gartner en position 30030 --> gauss en position 30130 --> gcw en position 30230 --> gelegenheid en position 30330 --> genlock en position 30430 --> geos en position 30530 --> gets en position 30630 --> ghq en position 30730 --> gillow en position 30830 --> giyx en position 30930 --> glavkosmos en position 31030 --> glow en position 31130 --> gnu en position 31230 --> goggleless en position 31330 --> good en position 31430 --> goto en position 31530 --> gpyz en position 31630 --> grammi en position 31730 --> grassy en position 31830 --> green's en position 31930 --> grieved en position 32030 --> groping en position 32130 --> grungy en position 32230 --> guardrail en position 32330 --> gulped en position 32430 --> gushed en position 32530 --> gxs en position 32630 --> haalbaarheid en position 32730 --> hagen en position 32830 --> halderc en position 32930 --> hamlin en position 33030 --> handout en position 33130 --> harassment en position 33230 --> harleys en position 33330 --> hasanali en position 33430 --> haunts en position 33530 --> hbpeltz en position 33630 --> headspace en position 33730 --> heb en position 33830 --> heinous en position 33930 --> helps en position 34030 --> herbison en position 34130 --> herzegovine en position 34230 --> hfpah en position 34330 --> hierarchical en position 34430 --> himem en position 34530 --> hiss en position 34630 --> hkcxxkc en position 34730 --> hob en position 34830 --> hole en position 34930 --> homesick en position 35030 --> hoodwink en position 35130 --> horrified en position 35230 --> houda en position 35330 --> hphcd en position 35430 --> hsczllqc en position 35530 --> hugging en position 35630 --> hundread en position 35730 --> huusr en position 35830 --> hydroxyl en position 35930 --> hypoxemia en position 36030 --> iaa en position 36130 --> ic's en position 36230 --> idaho en position 36330 --> idraw's en position 36430 --> ignitions en position 36530 --> iipa en position 36630 --> ilitch en position 36730 --> imagewidth en position 36830 --> immmense en position 36930 --> impedes en position 37030 --> importation en position 37130 --> imrlk en position 37230 --> incestual en position 37330 --> inconveniently en position 37430 --> independance en position 37530 --> indonesie en position 37630 --> inexperienced en position 37730 --> inflateble en position 37830 --> ingerle en position 37930 --> initializes en position 38030 --> innovators en position 38130 --> insemination en position 38230 --> instdatflags en position 38330 --> insusceptible en position 38430 --> interative en position 38530 --> interleaved en position 38630 --> interrupt en position 38730 --> intrepid en position 38830 --> inverted en position 38930 --> iorating en position 39030 --> irag en position 39130 --> irregardless en position 39230 --> ish en position 39330 --> ispfmt en position 39430 --> itch en position 39530 --> ivc en position 39630 --> izi en position 39730 --> jaffe en position 39830 --> japlish en position 39930 --> jce en position 40030 --> jelloman en position 40130 --> jewel en position 40230 --> jiggled en position 40330 --> jjjkiz en position 40430 --> job en position 40530 --> jolted en position 40630 --> joyous en position 40730 --> jscotti en position 40830 --> judizers en position 40930 --> jur en position 41030 --> jwo en position 41130 --> k's en position 41230 --> kamieniecki en position 41330 --> karl en position 41430 --> kaukasier en position 41530 --> kdl en position 41630 --> kempf en position 41730 --> kettle en position 41830 --> kfss en position 41930 --> khojali en position 42030 --> kilcore en position 42130 --> kingsley's en position 42230 --> kjbis en position 42330 --> kleer en position 42430 --> knickle en position 42530 --> kocz en position 42630 --> kookiness en position 42730 --> koylerine en position 42830 --> kriger en position 42930 --> kte en position 43030 --> kurtaran en position 43130 --> kyrm en position 43230 --> laced en position 43330 --> lakshman en position 43430 --> lanes en position 43530 --> larly en position 43630 --> lattices en position 43730 --> laxemburg en position 43830 --> ldevy en position 43930 --> least en position 44030 --> lefts en position 44130 --> leland en position 44230 --> lerosse en position 44330 --> levinson en position 44430 --> lh's en position 44530 --> libertopian en position 44630 --> liechenstein en position 44730 --> liking en position 44830 --> linedraw en position 44930 --> liquid en position 45030 --> litterbox en position 45130 --> lkwj en position 45230 --> lobbed en position 45330 --> logic en position 45430 --> looker en position 45530 --> lot en position 45630 --> lpd en position 45730 --> lsmrn en position 45830 --> lugged en position 45930 --> luser en position 46030 --> lxmu en position 46130 --> lzn en position 46230 --> macaulay en position 46330 --> mackie's en position 46430 --> maddison en position 46530 --> magnetosphere en position 46630 --> mailstop en position 46730 --> maketheirday en position 46830 --> malmoe en position 46930 --> mandell en position 47030 --> manouver en position 47130 --> marb en position 47230 --> marke en position 47330 --> marsolais en position 47430 --> massachussetts en position 47530 --> mathematique en position 47630 --> mauro en position 47730 --> mazinkert en position 47830 --> mccarthy's en position 47930 --> mchlb en position 48030 --> mcu en position 48130 --> meanwhile en position 48230 --> mediated en position 48330 --> megaman en position 48430 --> mellows en position 48530 --> meningococcus en position 48630 --> merk en position 48730 --> metabolizes en position 48830 --> metropolis en position 48930 --> mfx'u en position 49030 --> mhsd en position 49130 --> microdevices en position 49230 --> midas en position 49330 --> mikhailovich en position 49430 --> milliwatts en position 49530 --> minimizing en position 49630 --> miri en position 49730 --> misinterpret en position 49830 --> mistated en position 49930 --> mize's en position 50030 --> mko en position 50130 --> mmd'k en position 50230 --> mnkirnah en position 50330 --> moderation en position 50430 --> moir en position 50530 --> monastery en position 50630 --> monotomic en position 50730 --> mops en position 50830 --> morse en position 50930 --> motif's en position 51030 --> mous en position 51130 --> mpkjao en position 51230 --> mqxt en position 51330 --> ms'lc en position 51430 --> mtkgc en position 51530 --> muftus en position 51630 --> multiple en position 51730 --> municipal en position 51830 --> musician en position 51930 --> mva en position 52030 --> mwwwp en position 52130 --> mylex en position 52230 --> mzuo en position 52330 --> nail en position 52430 --> naproxen en position 52530 --> nationalteam en position 52630 --> nazr en position 52730 --> ne'onatal en position 52830 --> needlesused en position 52930 --> neither en position 53030 --> netanyahu en position 53130 --> neuropharmacology en position 53230 --> newington en position 53330 --> nextsetlasteventtime en position 53430 --> nhtsa en position 53530 --> nielson en position 53630 --> ninjakun en position 53730 --> nka en position 53830 --> nmsca en position 53930 --> noiseless en position 54030 --> nono en position 54130 --> norm en position 54230 --> notesgroup en position 54330 --> np en position 54430 --> nsfgr en position 54530 --> nuisances en position 54630 --> nutshell en position 54730 --> nylanders en position 54830 --> o'yre en position 54930 --> obg en position 55030 --> observtions en position 55130 --> occurrence en position 55230 --> odishelidje en position 55330 --> officials en position 55430 --> ohmigod en position 55530 --> ol en position 55630 --> olvr en position 55730 --> oncs en position 55830 --> oooh en position 55930 --> ophthalmol en position 56030 --> optimism en position 56130 --> oratory en position 56230 --> organised en position 56330 --> orlii en position 56430 --> osco en position 56530 --> othello en position 56630 --> outcompete en position 56730 --> outshooting en position 56830 --> overgrazed en position 56930 --> overshadowed en position 57030 --> owg en position 57130 --> ozh en position 57230 --> paderborner en position 57330 --> pajz en position 57430 --> pancreas en position 57530 --> papresco en position 57630 --> paratroops en position 57730 --> parrotting en position 57830 --> pasha en position 57930 --> patches en position 58030 --> patton en position 58130 --> pbq en position 58230 --> peaceably en position 58330 --> peeing en position 58430 --> penely en position 58530 --> perakende en position 58630 --> perilous en position 58730 --> perplexed en position 58830 --> pertain en position 58930 --> petterson en position 59030 --> pgvznazz en position 59130 --> philbrick's en position 59230 --> phoosball en position 59330 --> physical en position 59430 --> pieces en position 59530 --> pilon's en position 59630 --> pirates en position 59730 --> pixt en position 59830 --> plainext en position 59930 --> platters en position 60030 --> pliable en position 60130 --> pluto en position 60230 --> pobox en position 60330 --> polaris en position 60430 --> polycontrast en position 60530 --> poor en position 60630 --> portion en position 60730 --> postdiarrheal en position 60830 --> pound en position 60930 --> ppi en position 61030 --> prating en position 61130 --> precompiled en position 61230 --> preferences en position 61330 --> preponderance en position 61430 --> pressman en position 61530 --> prf en position 61630 --> printing en position 61730 --> prober en position 61830 --> productions en position 61930 --> progresslively en position 62030 --> pronation en position 62130 --> proportional en position 62230 --> protections en position 62330 --> provocative en position 62430 --> psinet en position 62530 --> ptfe en position 62630 --> puffy en position 62730 --> punk en position 62830 --> pursues en position 62930 --> pwoodcoc en position 63030 --> qalui en position 63130 --> qgluje en position 63230 --> qmecp en position 63330 --> qro en position 63430 --> quadrinomials en position 63530 --> quarterfinals en position 63630 --> quickkeys en position 63730 --> qur'an en position 63830 --> qzdj en position 63930 --> radiators en position 64030 --> railrays en position 64130 --> ramps en position 64230 --> rapsheet en position 64330 --> rations en position 64430 --> rbecs en position 64530 --> rdg en position 64630 --> realistic en position 64730 --> reb en position 64830 --> recent en position 64930 --> recomendations en position 65030 --> recurrance en position 65130 --> reducible en position 65230 --> refinance en position 65330 --> regaining en position 65430 --> regulated en position 65530 --> reintroduced en position 65630 --> relegates en position 65730 --> remain en position 65830 --> renal en position 65930 --> repairmen en position 66030 --> reponse en position 66130 --> repulsion en position 66230 --> resepct en position 66330 --> resonators en position 66430 --> restating en position 66530 --> retentive en position 66630 --> reuse en position 66730 --> revolted en position 66830 --> rgan en position 66930 --> rica en position 67030 --> rifts en position 67130 --> rioting en position 67230 --> rjf' en position 67330 --> rlojsqk en position 67430 --> roadblocks en position 67530 --> rocked en position 67630 --> rolexen en position 67730 --> rootwindow en position 67830 --> rotting en position 67930 --> rpai en position 68030 --> rsk en position 68130 --> rudeness en position 68230 --> runway en position 68330 --> rvoj' en position 68430 --> ryza en position 68530 --> sack en position 68630 --> safhada en position 68730 --> salient en position 68830 --> sampo en position 68930 --> sankar en position 69030 --> satan en position 69130 --> save's en position 69230 --> scale en position 69330 --> scdrye en position 69430 --> schizophrenia en position 69530 --> schwan en position 69630 --> scorebook en position 69730 --> screenplay en position 69830 --> scuffed en position 69930 --> sean en position 70030 --> secretariat en position 70130 --> seens en position 70230 --> seleucids en position 70330 --> sences en position 70430 --> seperates en position 70530 --> serotonin en position 70630 --> setwutime en position 70730 --> sgfi en position 70830 --> shamed en position 70930 --> shayne en position 71030 --> sheridan en position 71130 --> shirazi en position 71230 --> shorm en position 71330 --> shred en position 71430 --> shzrchorci en position 71530 --> siegert en position 71630 --> sigpipe en position 71730 --> simlist en position 71830 --> sineva en position 71930 --> sisters en position 72030 --> ska en position 72130 --> skirts en position 72230 --> slanted en position 72330 --> sliders en position 72430 --> slowly en position 72530 --> smatterings en position 72630 --> smr'wg en position 72730 --> snif en position 72830 --> sobering en position 72930 --> softlanding en position 73030 --> solomon en position 73130 --> sonically en position 73230 --> soton en position 73330 --> sowetos en position 73430 --> sparc en position 73530 --> specialties en position 73630 --> speek en position 73730 --> spinach en position 73830 --> spokespeople en position 73930 --> spped en position 74030 --> sqa en position 74130 --> sqx en position 74230 --> ssns en position 74330 --> staircase en position 74430 --> stapleton en position 74530 --> staticgray en position 74630 --> steed en position 74730 --> stepwise en position 74830 --> stiehm en position 74930 --> stocking en position 75030 --> storeys en position 75130 --> strategists en position 75230 --> stricted en position 75330 --> sts'lm en position 75430 --> styling en position 75530 --> sublette en position 75630 --> subsonic en position 75730 --> successors en position 75830 --> suggestion en position 75930 --> summerall en position 76030 --> sununu en position 76130 --> superscape en position 76230 --> supprise en position 76330 --> surrogate en position 76430 --> suu en position 76530 --> swastikas en position 76630 --> swiped en position 76730 --> syk en position 76830 --> syndicate en position 76930 --> systen en position 77030 --> tachycardia en position 77130 --> takeover en position 77230 --> tandem en position 77330 --> tarih en position 77430 --> taurid en position 77530 --> tcy en position 77630 --> techpubs en position 77730 --> telefunken en position 77830 --> templevm en position 77930 --> teperman en position 78030 --> terror en position 78130 --> texel en position 78230 --> thankful en position 78330 --> themsselves en position 78430 --> thermogenic en position 78530 --> thinner en position 78630 --> thousands en position 78730 --> thshn en position 78830 --> tib en position 78930 --> tikht en position 79030 --> tinges en position 79130 --> tj en position 79230 --> tnd en position 79330 --> tokelau en position 79430 --> tony en position 79530 --> toricelli's en position 79630 --> totem en position 79730 --> toxic en position 79830 --> tractors en position 79930 --> trannys en position 80030 --> transjordan en position 80130 --> trapping en position 80230 --> trei en position 80330 --> tried en position 80430 --> triumvirate en position 80530 --> truecolor en position 80630 --> tsj en position 80730 --> tudjman en position 80830 --> turbomodem en position 80930 --> tutxp en position 81030 --> twinsun en position 81130 --> typist en position 81230 --> uartdata en position 81330 --> udh en position 81430 --> uhn en position 81530 --> ulcers en position 81630 --> umped en position 81730 --> unbaptist en position 81830 --> uncompressed en position 81930 --> undercurrent en position 82030 --> undertook en position 82130 --> unexpected en position 82230 --> unhookable en position 82330 --> unistd en position 82430 --> unlikly en position 82530 --> unpersuasive en position 82630 --> uns en position 82730 --> unsuspecting en position 82830 --> unworthy en position 82930 --> uplinked en position 83030 --> urbana en position 83130 --> usefull en position 83230 --> usualy en position 83330 --> utterances en position 83430 --> uxsd en position 83530 --> vagaries en position 83630 --> vanbiesbrouck's en position 83730 --> varis en position 83830 --> vbe en position 83930 --> vedio en position 84030 --> venetians en position 84130 --> verions en position 84230 --> vestnik en position 84330 --> vibrator en position 84430 --> viewdvi en position 84530 --> vinnaren en position 84630 --> visitation en position 84730 --> vlad en position 84830 --> vociferously en position 84930 --> volvo's en position 85030 --> vqr en position 85130 --> vukela en position 85230 --> vyjx en position 85330 --> wage en position 85430 --> wallets en position 85530 --> warehousemen en position 85630 --> wast en position 85730 --> waxed en position 85830 --> we'er en position 85930 --> weeker en position 86030 --> wellllll en position 86130 --> wether en position 86230 --> whcih en position 86330 --> whirrr en position 86430 --> whooped en position 86530 --> wiersema en position 86630 --> wilma en position 86730 --> wingz en position 86830 --> wiretapping en position 86930 --> wixer en position 87030 --> wnkretz en position 87130 --> wondrously en position 87230 --> workmanship en position 87330 --> wove en position 87430 --> wright en position 87530 --> wtih en position 87630 --> wwr en position 87730 --> xanadu en position 87830 --> xclrs en position 87930 --> xdum en position 88030 --> xgetmodifiermapping en position 88130 --> ximagehandler en position 88230 --> xlnth en position 88330 --> xmptablemakecolsfitquerywidth en position 88430 --> xpermits en position 88530 --> xrlogind en position 88630 --> xssr en position 88730 --> xtdestructor en position 88830 --> xtnargc en position 88930 --> xtsetvalues en position 89030 --> xvl en position 89130 --> xxxxdraft en position 89230 --> yale en position 89330 --> yax en position 89430 --> yell en position 89530 --> yielded en position 89630 --> ymp en position 89730 --> youngster's en position 89830 --> ytf en position 89930 --> ywvv en position 90030 --> zaire en position 90130 --> zcjjj en position 90230 --> zeta en position 90330 --> zimmermann en position 90430 --> zlp en position 90530 --> zodiacal en position 90630 --> zqww en position 90730 --> zumw en position 90830 --> zyv
# Importation des bibliothèques nécessaires
from collections import Counter # Pour compter les occurrences de mots
import nltk # Natural Language Toolkit
from nltk.corpus import words # Vocabulaire anglais de NLTK
# Téléchargement du vocabulaire anglais depuis NLTK
nltk.download('words')
# Création d'un ensemble du vocabulaire anglais pour vérification rapide
english_vocab = set(words.words())
# Extraction de tous les mots du DataFrame (aplatissement de la liste de listes)
all_words = [word for mots in newsgroups_df_neitoie['les_mots'] for word in mots]
# Comptage des occurrences de chaque mot
word_counts = Counter(all_words)
# Création d'un index de mots filtrés selon plusieurs critères:
index_mots = sorted(set(
mot for mot in all_words
if mot[0].isalpha() # Le mot commence par une lettre
and mot.isalpha() # Le mot ne contient que des lettres
and 3 <= len(mot) <= 20 # Longueur entre 3 et 20 caractères
and word_counts[mot] >= 5 # Apparaît au moins 5 fois
and mot.lower() in english_vocab # Fait partie du vocabulaire anglais
))
# Affichage des statistiques
print("Nombre de mots trouvés: ", len(index_mots))
print("Les 10 premiers :", index_mots[0:10])
# Vérification aléatoire de la qualité des résultats
for i in range(30, len(index_mots), 100): # Par pas de 100 à partir de l'index 30
print("\ten position ", i, " --> ", index_mots[i])
[nltk_data] Downloading package words to [nltk_data] /Users/yuxiangzhang/nltk_data... [nltk_data] Package words is already up-to-date!
Nombre de mots trouvés: 11928 Les 10 premiers : ['abandon', 'abandoned', 'abbey', 'abbreviation', 'abdomen', 'abdominal', 'abduct', 'aberrant', 'aberration', 'abhor'] en position 30 --> absolute en position 130 --> acupuncture en position 230 --> aftermath en position 330 --> alpine en position 430 --> angular en position 530 --> applicant en position 630 --> ashamed en position 730 --> attractive en position 830 --> bacterium en position 930 --> batting en position 1030 --> betting en position 1130 --> blink en position 1230 --> bound en position 1330 --> brutal en position 1430 --> cain en position 1530 --> carry en position 1630 --> chalk en position 1730 --> choleric en position 1830 --> click en position 1930 --> collapse en position 2030 --> compatible en position 2130 --> condensed en position 2230 --> conspiracy en position 2330 --> convinced en position 2430 --> coupon en position 2530 --> cruel en position 2630 --> damnation en position 2730 --> deductive en position 2830 --> dental en position 2930 --> deviant en position 3030 --> directly en position 3130 --> disposition en position 3230 --> doll en position 3330 --> droplet en position 3430 --> ecstatic en position 3530 --> emotional en position 3630 --> enthusiasm en position 3730 --> ethnical en position 3830 --> exhibition en position 3930 --> fabrication en position 4030 --> feared en position 4130 --> find en position 4230 --> flung en position 4330 --> fortunate en position 4430 --> functionality en position 4530 --> generation en position 4630 --> godhead en position 4730 --> grill en position 4830 --> hander en position 4930 --> hearts en position 5030 --> hobgoblin en position 5130 --> humane en position 5230 --> imagination en position 5330 --> incidental en position 5430 --> infected en position 5530 --> insinuating en position 5630 --> intern en position 5730 --> irrational en position 5830 --> jury en position 5930 --> lamp en position 6030 --> legality en position 6130 --> liner en position 6230 --> lose en position 6330 --> male en position 6430 --> mater en position 6530 --> meshed en position 6630 --> miracle en position 6730 --> monogamous en position 6830 --> mun en position 6930 --> needing en position 7030 --> nonsense en position 7130 --> observing en position 7230 --> oppose en position 7330 --> oval en position 7430 --> paperback en position 7530 --> pause en position 7630 --> perspective en position 7730 --> pipe en position 7830 --> poisoning en position 7930 --> pounding en position 8030 --> pretended en position 8130 --> progressive en position 8230 --> provoking en position 8330 --> queer en position 8430 --> rare en position 8530 --> recommendation en position 8630 --> registered en position 8730 --> repeal en position 8830 --> respondent en position 8930 --> rick en position 9030 --> round en position 9130 --> sang en position 9230 --> scratching en position 9330 --> sence en position 9430 --> shark en position 9530 --> sidewalk en position 9630 --> skin en position 9730 --> snide en position 9830 --> southeast en position 9930 --> spoiled en position 10030 --> statistically en position 10130 --> stratospheric en position 10230 --> substantiate en position 10330 --> supposing en position 10430 --> sync en position 10530 --> technical en position 10630 --> thats en position 10730 --> tic en position 10830 --> totalitarian en position 10930 --> treason en position 11030 --> turbines en position 11130 --> unconnected en position 11230 --> unleaded en position 11330 --> upward en position 11430 --> vent en position 11530 --> vodka en position 11630 --> watched en position 11730 --> wholesale en position 11830 --> working
Apprentissage supervisé¶
Tâches: évaluation d'algorithmes et de représentations des données.
- classification binaire
- classification multi-classe
Etudes suggérées:
- représentations des données
- avec ou sans suppression des stopwords
- différentes représentations: bag-of-words binaire, avec comptage, avec fréquences, avec tfidf
- différents classifiers:
- perceptron,
- k-plus proches voisins avec distance euclidienne,
- k-plus proches voisins avec distance cosinus (cf. TD),
- Naives Bayes,
- arbres de décision
- analyse des résultats:
- accuracy, temps d'exécutions
- score fold par fold
- matrice de confusion
Tâches à réaliser¶
def bag_of_words_sparse_manual(texts_tokenized, vocab, mode="count"):
"""
:param mode: valeurs possibles : 'count', 'binary', 'freq'
"""
vocab_index = {word: i for i, word in enumerate(vocab)}
rows, cols, data = [], [], []
for row_idx, tokens in enumerate(texts_tokenized):
word_counts = {}
for word in tokens:
if word in vocab_index:
col_idx = vocab_index[word]
word_counts[col_idx] = word_counts.get(col_idx, 0) + 1
total_words = sum(word_counts.values())
for col_idx, count in word_counts.items():
rows.append(row_idx)
cols.append(col_idx)
if mode == "count":
value = count
elif mode == "binary":
value = 1
elif mode == "freq":
value = count / total_words
else:
raise ValueError("Mode non supporté : choisissez parmi 'count', 'binary', 'freq'")
data.append(value)
n_rows = len(texts_tokenized)
n_cols = len(vocab)
sparse_matrix = csr_matrix((data, (rows, cols)), shape=(n_rows, n_cols), dtype=float)
return sparse_matrix, vocab_index
def bag_of_words_tfidf_manual(textes_tokenisés, vocabulaire):
"""
:param textes_tokenisés: Liste de listes de mots (tokens)
:param vocabulaire: liste des mots du vocabulaire
:return: matrice creuse TF-IDF (csr_matrix), dictionnaire {mot: index}
"""
vocab_index = {mot: i for i, mot in enumerate(vocabulaire)}
N_docs = len(textes_tokenisés) # Nombre de documents
# 1. Calcul de la DF (Document Frequency)
df_counts = np.zeros(len(vocabulaire))
for tokens in textes_tokenisés:
mots_uniques = set(tokens)
for mot in mots_uniques:
if mot in vocab_index:
df_counts[vocab_index[mot]] += 1
# Éviter la division par 0
df_counts[df_counts == 0] = 1
# 2. Construction de la matrice creuse TF-IDF
lignes, colonnes, données = [], [], []
for doc_idx, tokens in enumerate(textes_tokenisés):
tf_counts = {}
for mot in tokens:
if mot in vocab_index:
idx = vocab_index[mot]
tf_counts[idx] = tf_counts.get(idx, 0) + 1
total_mots = sum(tf_counts.values())
for idx, tf in tf_counts.items():
tf_val = tf / total_mots
idf_val = math.log(N_docs / df_counts[idx])
tfidf = tf_val * idf_val
lignes.append(doc_idx)
colonnes.append(idx)
données.append(tfidf)
mat = csr_matrix((données, (lignes, colonnes)), shape=(N_docs, len(vocabulaire)))
return mat, vocab_index
# Appel de la fonction pour générer la matrice BoW
X_sparse, vec = bag_of_words_sparse_manual(newsgroups_df_neitoie['les_mots'], index_mots)
# Vérification de la forme de la matrice
print(X_sparse.shape)
print(type(X_sparse))
# Conversion en DataFrame pour affichage
df_bow = pd.DataFrame(X_sparse.toarray(), columns=index_mots)
df_bow
(18466, 11928) <class 'scipy.sparse._csr.csr_matrix'>
| abandon | abandoned | abbey | abbreviation | abdomen | abdominal | abduct | aberrant | aberration | abhor | ... | zeta | zinc | zip | zipper | zippy | zodiacal | zone | zoo | zooid | zoom | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | ... | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 |
| 1 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | ... | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 |
| 2 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | ... | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 |
| 3 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | ... | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 |
| 4 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | ... | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 |
| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |
| 18461 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | ... | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 |
| 18462 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | ... | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 |
| 18463 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | ... | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 |
| 18464 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | ... | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 |
| 18465 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | ... | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 |
18466 rows × 11928 columns
np.random.seed(42) # Pour reproductibilité
# Pourcentage d'exemples de chaque classe à garder :
taux = 0.1 # 10%
# Déclaration des variables qui seront initialisées dans la boucle :
df_train = pd.DataFrame()
df_test = pd.DataFrame()
les_targets = newsgroups_df_neitoie['target'].unique()
for l in les_targets:
nb_total = newsgroups_df_neitoie['target'].value_counts()[l] # Nombre total d'exemples pour la classe l
nb_pris = int(nb_total * taux) # Nombre d'exemples à prendre pour l'entraînement
print(f"Nombre d'exemples du label {l} pris pour apprendre: {nb_pris}")
# Récupération des indices des exemples de cette classe
les_ids = newsgroups_df_neitoie[newsgroups_df_neitoie['target'] == l].index.to_list()
# Mélanger les indices aléatoirement
np.random.shuffle(les_ids)
# Séparer les indices pour l'entraînement et le test
ids_train = les_ids[:nb_pris] # 10% pour l'entraînement
ids_test = les_ids[nb_pris:] # Le reste pour le test
# Ajouter les données correspondantes aux DataFrames
df_train = pd.concat([df_train, newsgroups_df_neitoie.loc[ids_train]], ignore_index=True)
df_test = pd.concat([df_test, newsgroups_df_neitoie.loc[ids_test]], ignore_index=True)
# Résultat :
print(f"Dimension de df_train:\t{df_train.shape}")
print(f"Dimension de df_test:\t{df_test.shape}")
Nombre d'exemples du label 10 pris pour apprendre: 98 Nombre d'exemples du label 3 pris pour apprendre: 97 Nombre d'exemples du label 17 pris pour apprendre: 92 Nombre d'exemples du label 4 pris pour apprendre: 93 Nombre d'exemples du label 12 pris pour apprendre: 96 Nombre d'exemples du label 19 pris pour apprendre: 60 Nombre d'exemples du label 11 pris pour apprendre: 96 Nombre d'exemples du label 13 pris pour apprendre: 96 Nombre d'exemples du label 0 pris pour apprendre: 78 Nombre d'exemples du label 8 pris pour apprendre: 97 Nombre d'exemples du label 7 pris pour apprendre: 94 Nombre d'exemples du label 5 pris pour apprendre: 98 Nombre d'exemples du label 1 pris pour apprendre: 95 Nombre d'exemples du label 14 pris pour apprendre: 96 Nombre d'exemples du label 16 pris pour apprendre: 89 Nombre d'exemples du label 6 pris pour apprendre: 96 Nombre d'exemples du label 9 pris pour apprendre: 96 Nombre d'exemples du label 18 pris pour apprendre: 76 Nombre d'exemples du label 2 pris pour apprendre: 95 Nombre d'exemples du label 15 pris pour apprendre: 98 Dimension de df_train: (1836, 3) Dimension de df_test: (16630, 3)
Classifier Perceptron¶
# ======================================================
# Classification binaire avec Perceptron - Version 1
# ======================================================
# Cette version utilise une méthode de conversion directe des données
# via la fonction df2array (non détaillée ici)
# Sélection des deux classes à classifier
classe1 = 0
classe2 = 1
# Filtrage des données d'entraînement et de test
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en format binaire (-1/+1)
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Préparation des données d'entraînement et de test
X_train_bin = ut.df2array(df_binaire, index_mots) # Conversion des features
y_train_bin = df_binaire['target_bin'].values # Labels d'entraînement
X_test_bin = ut.df2array(df_test_bin, index_mots) # Conversion des features
y_test_bin = df_test_bin['target_bin'].values # Labels de test
# Initialisation du perceptron
perceptron = classif.ClassifierPerceptron(input_dimension=X_train_bin.shape[1], learning_rate=0.01)
# Listes pour stocker les performances
train_acc = [] # Précision sur le train set
test_acc = [] # Précision sur le test set
# Boucle d'entraînement
N = 100 # Nombre d'itérations
# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
# Étape d'entraînement
perceptron.train_step(X_train_bin, y_train_bin)
# Prédictions et calcul de l'accuracy
y_train_pred = np.array([perceptron.predict(x) for x in X_train_bin])
y_test_pred = np.array([perceptron.predict(x) for x in X_test_bin])
# Enregistrement des performances
train_acc.append((y_train_pred == y_train_bin).mean())
test_acc.append((y_test_pred == y_test_bin).mean())
end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")
# Visualisation des résultats
plt.plot(range(1,N+1),train_acc, label='Train')
plt.plot(range(1,N+1),test_acc, label='Test')
plt.ylabel('Accuracy')
plt.xlabel("Etape")
plt.title("Évolution de l'accuracy pendant l'entraînement")
plt.legend()
plt.grid(True)
plt.show()
# Affichage des résultats finaux
print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Temps total d'entraînement : 1.2524452209472656 secondes
Accuracy finale (train): 0.9884393063583815 Accuracy finale (test) : 0.8220663265306123 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0)] Taux moyen de bonne classification : 0.9882 Écart-type : 0.0144
# ======================================================
# Classification binaire avec Bag-of-Words (Binaire) avec Perceptron - Version 2
# ======================================================
# Cette version utilise explicitement un modèle Bag-of-Words (BoW)
# pour la vectorisation des textes
# Sélection des classes (identique à la version 1)
classe1 = 0
classe2 = 1
# Filtrage des données (identique à la version 1)
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels (identique à la version 1)
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Initialisation du perceptron
perceptron = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=0.01)
# Entraînement et évaluation
N = 100 # Nombre d'itérations
train_acc, test_acc = [], [] # Stockage des performances
# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
# Étape d'entraînement
perceptron.train_step(X_train, y_train_bin)
# Prédictions
y_train_pred = np.array([perceptron.predict(x) for x in X_train])
y_test_pred = np.array([perceptron.predict(x) for x in X_test])
# Calcul et enregistrement des performances
train_acc.append((y_train_pred == y_train_bin).mean())
test_acc.append((y_test_pred == y_test_bin).mean())
end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")
# Visualisation des résultats
plt.plot(range(1,N+1), train_acc, label="Train")
plt.plot(range(1,N+1), test_acc, label="Test")
plt.xlabel("Itération")
plt.ylabel("Accuracy")
plt.title("Performance du Perceptron avec BoW (mode binaire)")
plt.legend()
plt.grid(True)
plt.show()
# Affichage des résultats finaux
print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Temps total d'entraînement : 0.6399490833282471 secondes
Accuracy finale (train): 0.9884393063583815 Accuracy finale (test) : 0.8233418367346939 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0)] Taux moyen de bonne classification : 0.9882 Écart-type : 0.0144
# =================================================================
# Classification binaire avec Comptage de mots (Bag-of-Words count) avec Perceptron - Version 3
# =================================================================
# Cette version utilise la fréquence brute des mots comme caractéristiques
# Définition des classes à classifier
classe1 = 0
classe2 = 1
# Préparation des données - Filtrage des classes sélectionnées
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Transformation des labels en format binaire (-1 pour classe1, +1 pour classe2)
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode comptage
# Le mode "count" enregistre le nombre d'occurrences de chaque mot
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Initialisation du perceptron avec le nombre de caractéristiques et taux d'apprentissage
perceptron = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=0.01)
# Boucle d'entraînement et évaluation
N = 100 # Nombre d'itérations
train_acc, test_acc = [], [] # Stockage des précisions
# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
# Phase d'entraînement
perceptron.train_step(X_train, y_train_bin)
# Prédictions sur les ensembles d'entraînement et de test
y_train_pred = np.array([perceptron.predict(x) for x in X_train])
y_test_pred = np.array([perceptron.predict(x) for x in X_test])
# Calcul et enregistrement des précisions
train_acc.append((y_train_pred == y_train_bin).mean())
test_acc.append((y_test_pred == y_test_bin).mean())
end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")
# Visualisation des résultats
plt.plot(range(1,N+1), train_acc, label="Train")
plt.plot(range(1,N+1), test_acc, label="Test")
plt.xlabel("Itération")
plt.ylabel("Accuracy")
plt.title("Perceptron avec BoW (mode=count)")
plt.legend()
plt.grid(True)
plt.show()
print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Temps total d'entraînement : 0.6322243213653564 secondes
Accuracy finale (train): 0.9884393063583815 Accuracy finale (test) : 0.8418367346938775 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(1.0), np.float64(0.9705882352941176), np.float64(0.9705882352941176), np.float64(0.9705882352941176), np.float64(0.9705882352941176)] Taux moyen de bonne classification : 0.9765 Écart-type : 0.0118
# =================================================================
# Classification binaire avec Fréquence relative (Bag-of-Words freq) avec Perceptron - Version 4
# =================================================================
# Cette version utilise la fréquence relative des mots comme caractéristiques
classe1 = 0
classe2 = 1
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode fréquence
# Le mode "freq" utilise la fréquence relative (occurrences normalisées par document)
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
perceptron = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=0.01)
N = 100
train_acc, test_acc = [], []
# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
perceptron.train_step(X_train, y_train_bin)
y_train_pred = np.array([perceptron.predict(x) for x in X_train])
y_test_pred = np.array([perceptron.predict(x) for x in X_test])
train_acc.append((y_train_pred == y_train_bin).mean())
test_acc.append((y_test_pred == y_test_bin).mean())
end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")
plt.plot(range(1,N+1), train_acc, label="Train")
plt.plot(range(1,N+1), test_acc, label="Test")
plt.xlabel("Itération")
plt.ylabel("Accuracy")
plt.title("Perceptron avec BoW (mode=freq)")
plt.legend()
plt.grid(True)
plt.show()
print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Temps total d'entraînement : 0.6305558681488037 secondes
Accuracy finale (train): 0.9884393063583815 Accuracy finale (test) : 0.8392857142857143 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8529 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8529 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.7647 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.7941 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8235 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.8529411764705882), np.float64(0.8529411764705882), np.float64(0.7647058823529411), np.float64(0.7941176470588235), np.float64(0.8235294117647058)] Taux moyen de bonne classification : 0.8176 Écart-type : 0.0343
# =================================================================
# Classification binaire avec TF-IDF avec Perceptron - Version 5
# =================================================================
# Cette version utilise le score TF-IDF comme caractéristiques
classe1 = 0
classe2 = 1
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle TF-IDF
# TF-IDF pondère les mots par leur importance dans le document et le corpus
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
perceptron = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=0.01)
N = 100
train_acc, test_acc = [], []
# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
perceptron.train_step(X_train, y_train_bin)
y_train_pred = np.array([perceptron.predict(x) for x in X_train])
y_test_pred = np.array([perceptron.predict(x) for x in X_test])
train_acc.append((y_train_pred == y_train_bin).mean())
test_acc.append((y_test_pred == y_test_bin).mean())
end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")
plt.plot(range(1,N+1), train_acc, label="Train")
plt.plot(range(1,N+1), test_acc, label="Test")
plt.xlabel("Itération")
plt.ylabel("Accuracy")
plt.title("Perceptron avec BoW (mode=tfidf)")
plt.legend()
plt.grid(True)
plt.show()
print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Temps total d'entraînement : 0.6359288692474365 secondes
Accuracy finale (train): 0.9884393063583815 Accuracy finale (test) : 0.8367346938775511 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8824 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.7941 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.7647 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8235 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9118 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.8823529411764706), np.float64(0.7941176470588235), np.float64(0.7647058823529411), np.float64(0.8235294117647058), np.float64(0.9117647058823529)] Taux moyen de bonne classification : 0.8353 Écart-type : 0.0546
# =================================================================
# Classification multi-classe avec (Bag-of-Words binary) avec perceptron - Version 1
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "binary" # "binary", "count", "freq", "tfidf"(fonction bag_of_words_tfidf_manual)
learning_rate = 0.01
N = 100 # Nombre d'itérations pour le perceptron
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle Multi-classe (OAA)
# ---------------------------
# Initialisation du classifieur de base (Perceptron)
perceptron_base = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=learning_rate)
# Construction du classifieur multi-classe OAA
oaa_classifier = classif.ClassifierMultiOAA(perceptron_base)
# Chronométrage
start = time.time()
oaa_classifier.train(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = np.array([oaa_classifier.predict(x) for x in X_train])
y_test_pred = np.array([oaa_classifier.predict(x) for x in X_test])
# ---------------------------
# Évaluation des performances
# ---------------------------
# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec (Bag-of-Words binary) avec perceptron")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
# Pour validation croisée, on réinitialise un modèle neuf
def create_new_oaa():
base = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=learning_rate)
return classif.ClassifierMultiOAA(base)
perf = []
for i in range(nb_folds):
Xapp, Yapp, Xtest, Ytest = ev.crossval_strat(X_train, y_train_multi, nb_folds, i)
clf = create_new_oaa()
clf.train(Xapp, Yapp)
Y_pred = np.array([clf.predict(x) for x in Xtest])
acc = np.mean(Y_pred == Ytest)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe) : 1.2713229656219482 secondes Accuracy entraînement : 0.9875 Accuracy test : 0.4583
Itération 0: Accuracy = 0.4556 Itération 1: Accuracy = 0.4222 Itération 2: Accuracy = 0.4472 Itération 3: Accuracy = 0.4000 Itération 4: Accuracy = 0.4583 Taux moyen : 0.4367, Écart-type : 0.0223
# =================================================================
# Classification multi-classe avec (Bag-of-Words comptage) avec perceptron - Version 2
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "count" # "binary", "count", "freq", "tfidf"(fonction bag_of_words_tfidf_manual)
learning_rate = 0.01
N = 100 # Nombre d'itérations pour le perceptron
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle Multi-classe (OAA)
# ---------------------------
# Initialisation du classifieur de base (Perceptron)
perceptron_base = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=learning_rate)
# Construction du classifieur multi-classe OAA
oaa_classifier = classif.ClassifierMultiOAA(perceptron_base)
# Chronométrage
start = time.time()
oaa_classifier.train(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = np.array([oaa_classifier.predict(x) for x in X_train])
y_test_pred = np.array([oaa_classifier.predict(x) for x in X_test])
# ---------------------------
# Évaluation des performances
# ---------------------------
# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec (Bag-of-Words comptage) avec perceptron")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
# Pour validation croisée, on réinitialise un modèle neuf
def create_new_oaa():
base = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=learning_rate)
return classif.ClassifierMultiOAA(base)
perf = []
for i in range(nb_folds):
Xapp, Yapp, Xtest, Ytest = ev.crossval_strat(X_train, y_train_multi, nb_folds, i)
clf = create_new_oaa()
clf.train(Xapp, Yapp)
Y_pred = np.array([clf.predict(x) for x in Xtest])
acc = np.mean(Y_pred == Ytest)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe) : 1.647778034210205 secondes Accuracy entraînement : 0.9875 Accuracy test : 0.4396
Itération 0: Accuracy = 0.4306 Itération 1: Accuracy = 0.4167 Itération 2: Accuracy = 0.4028 Itération 3: Accuracy = 0.4111 Itération 4: Accuracy = 0.4083 Taux moyen : 0.4139, Écart-type : 0.0095
# =================================================================
# Classification multi-classe avec (Bag-of-Words frequence) avec perceptron - Version 3
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "freq" # "binary", "count", "freq", "tfidf"(fonction bag_of_words_tfidf_manual)
learning_rate = 0.01
N = 100 # Nombre d'itérations pour le perceptron
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle Multi-classe (OAA)
# ---------------------------
# Initialisation du classifieur de base (Perceptron)
perceptron_base = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=learning_rate)
# Construction du classifieur multi-classe OAA
oaa_classifier = classif.ClassifierMultiOAA(perceptron_base)
# Chronométrage
start = time.time()
oaa_classifier.train(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = np.array([oaa_classifier.predict(x) for x in X_train])
y_test_pred = np.array([oaa_classifier.predict(x) for x in X_test])
# ---------------------------
# Évaluation des performances
# ---------------------------
# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec (Bag-of-Words frequence) avec perceptron")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
# Pour validation croisée, on réinitialise un modèle neuf
def create_new_oaa():
base = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=learning_rate)
return classif.ClassifierMultiOAA(base)
perf = []
for i in range(nb_folds):
Xapp, Yapp, Xtest, Ytest = ev.crossval_strat(X_train, y_train_multi, nb_folds, i)
clf = create_new_oaa()
clf.train(Xapp, Yapp)
Y_pred = np.array([clf.predict(x) for x in Xtest])
acc = np.mean(Y_pred == Ytest)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe) : 1.660815954208374 secondes Accuracy entraînement : 0.9875 Accuracy test : 0.4317
Itération 0: Accuracy = 0.4194 Itération 1: Accuracy = 0.3833 Itération 2: Accuracy = 0.3750 Itération 3: Accuracy = 0.4000 Itération 4: Accuracy = 0.4222 Taux moyen : 0.4000, Écart-type : 0.0188
# =================================================================
# Classification multi-classe avec (Bag-of-Words tf-idf) avec perceptron - Version 4
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
learning_rate = 0.01
N = 100 # Nombre d'itérations pour le perceptron
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle Multi-classe (OAA)
# ---------------------------
# Initialisation du classifieur de base (Perceptron)
perceptron_base = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=learning_rate)
# Construction du classifieur multi-classe OAA
oaa_classifier = classif.ClassifierMultiOAA(perceptron_base)
# Chronométrage
start = time.time()
oaa_classifier.train(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = np.array([oaa_classifier.predict(x) for x in X_train])
y_test_pred = np.array([oaa_classifier.predict(x) for x in X_test])
# ---------------------------
# Évaluation des performances
# ---------------------------
# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec (Bag-of-Words tf-idf) avec perceptron")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
# Pour validation croisée, on réinitialise un modèle neuf
def create_new_oaa():
base = classif.ClassifierPerceptron(input_dimension=X_train.shape[1], learning_rate=learning_rate)
return classif.ClassifierMultiOAA(base)
perf = []
for i in range(nb_folds):
Xapp, Yapp, Xtest, Ytest = ev.crossval_strat(X_train, y_train_multi, nb_folds, i)
clf = create_new_oaa()
clf.train(Xapp, Yapp)
Y_pred = np.array([clf.predict(x) for x in Xtest])
acc = np.mean(Y_pred == Ytest)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe) : 1.1476762294769287 secondes Accuracy entraînement : 0.9875 Accuracy test : 0.4479
Itération 0: Accuracy = 0.4333 Itération 1: Accuracy = 0.4056 Itération 2: Accuracy = 0.3750 Itération 3: Accuracy = 0.4222 Itération 4: Accuracy = 0.4000 Taux moyen : 0.4072, Écart-type : 0.0200
Classifier PerceptronBiais¶
# ======================================================
# Classification binaire avec PerceptronBiais - Version 1
# ======================================================
# Sélection des deux classes à classifier
classe1 = 0
classe2 = 1
# Filtrage des données d'entraînement et de test
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en format binaire (-1/+1)
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Préparation des données d'entraînement et de test
X_train_bin = ut.df2array(df_binaire, index_mots) # Conversion des features
y_train_bin = df_binaire['target_bin'].values # Labels d'entraînement
X_test_bin = ut.df2array(df_test_bin, index_mots) # Conversion des features
y_test_bin = df_test_bin['target_bin'].values # Labels de test
# Initialisation du perceptron AVEC BIAIS
perceptron = classif.ClassifierPerceptronBiais(input_dimension=X_train_bin.shape[1], learning_rate=0.01)
# Listes pour stocker les performances
train_acc = [] # Précision sur le train set
test_acc = [] # Précision sur le test set
# Boucle d'entraînement
N = 100 # Nombre d'itérations
# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
# Étape d'entraînement
perceptron.train_step(X_train_bin, y_train_bin)
# Prédictions et calcul de l'accuracy
y_train_pred = np.array([perceptron.predict(x) for x in X_train_bin])
y_test_pred = np.array([perceptron.predict(x) for x in X_test_bin])
# Enregistrement des performances
train_acc.append((y_train_pred == y_train_bin).mean())
test_acc.append((y_test_pred == y_test_bin).mean())
end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")
# Visualisation des résultats
plt.plot(range(1, N+1), train_acc, label='Train')
plt.plot(range(1, N+1), test_acc, label='Test')
plt.ylabel('Accuracy')
plt.xlabel("Étape")
plt.title("Évolution de l'accuracy pendant l'entraînement (avec biais)")
plt.legend()
plt.grid(True)
plt.show()
# Affichage des résultats finaux
print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Temps total d'entraînement : 1.2888462543487549 secondes
Accuracy finale (train): 0.9942196531791907 Accuracy finale (test) : 0.8647959183673469 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0)] Taux moyen de bonne classification : 0.9882 Écart-type : 0.0144
# ======================================================
# Classification binaire avec Bag-of-Words (Binaire) avec PerceptronBiais - Version 2
# ======================================================
# Cette version utilise explicitement un modèle Bag-of-Words (BoW)
# pour la vectorisation des textes
# Sélection des classes (identique à la version 1)
classe1 = 0
classe2 = 1
# Filtrage des données (identique à la version 1)
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels (identique à la version 1)
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Initialisation du perceptron
perceptron = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=0.01)
# Entraînement et évaluation
N = 100 # Nombre d'itérations
train_acc, test_acc = [], [] # Stockage des performances
# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
# Étape d'entraînement
perceptron.train_step(X_train, y_train_bin)
# Prédictions
y_train_pred = np.array([perceptron.predict(x) for x in X_train])
y_test_pred = np.array([perceptron.predict(x) for x in X_test])
# Calcul et enregistrement des performances
train_acc.append((y_train_pred == y_train_bin).mean())
test_acc.append((y_test_pred == y_test_bin).mean())
end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")
# Visualisation des résultats
plt.plot(range(1,N+1), train_acc, label="Train")
plt.plot(range(1,N+1), test_acc, label="Test")
plt.xlabel("Itération")
plt.ylabel("Accuracy")
plt.title("Performance du Perceptron avec BoW (mode binaire)")
plt.legend()
plt.grid(True)
plt.show()
# Affichage des résultats finaux
print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Temps total d'entraînement : 0.6842498779296875 secondes
Accuracy finale (train): 0.9942196531791907 Accuracy finale (test) : 0.8628826530612245 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0)] Taux moyen de bonne classification : 0.9882 Écart-type : 0.0144
# =================================================================
# Classification binaire avec Comptage de mots (Bag-of-Words count) avec PerceptronBiais - Version 3
# =================================================================
# Cette version utilise la fréquence brute des mots comme caractéristiques
# Définition des classes à classifier
classe1 = 0
classe2 = 1
# Préparation des données - Filtrage des classes sélectionnées
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Transformation des labels en format binaire (-1 pour classe1, +1 pour classe2)
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode comptage
# Le mode "count" enregistre le nombre d'occurrences de chaque mot
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Initialisation du perceptron avec le nombre de caractéristiques et taux d'apprentissage
perceptron = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=0.01)
# Boucle d'entraînement et évaluation
N = 100 # Nombre d'itérations
train_acc, test_acc = [], [] # Stockage des précisions
# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
# Phase d'entraînement
perceptron.train_step(X_train, y_train_bin)
# Prédictions sur les ensembles d'entraînement et de test
y_train_pred = np.array([perceptron.predict(x) for x in X_train])
y_test_pred = np.array([perceptron.predict(x) for x in X_test])
# Calcul et enregistrement des précisions
train_acc.append((y_train_pred == y_train_bin).mean())
test_acc.append((y_test_pred == y_test_bin).mean())
end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")
# Visualisation des résultats
plt.plot(range(1,N+1), train_acc, label="Train")
plt.plot(range(1,N+1), test_acc, label="Test")
plt.xlabel("Itération")
plt.ylabel("Accuracy")
plt.title("Perceptron avec BoW (mode=count)")
plt.legend()
plt.grid(True)
plt.show()
print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Temps total d'entraînement : 0.7144351005554199 secondes
Accuracy finale (train): 0.9942196531791907 Accuracy finale (test) : 0.8654336734693877 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0)] Taux moyen de bonne classification : 0.9882 Écart-type : 0.0144
# =================================================================
# Classification binaire avec Fréquence relative (Bag-of-Words freq) avec PerceptronBiais - Version 4
# =================================================================
# Cette version utilise la fréquence relative des mots comme caractéristiques
classe1 = 0
classe2 = 1
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode fréquence
# Le mode "freq" utilise la fréquence relative (occurrences normalisées par document)
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
perceptron = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=0.01)
N = 100
train_acc, test_acc = [], []
# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
perceptron.train_step(X_train, y_train_bin)
y_train_pred = np.array([perceptron.predict(x) for x in X_train])
y_test_pred = np.array([perceptron.predict(x) for x in X_test])
train_acc.append((y_train_pred == y_train_bin).mean())
test_acc.append((y_test_pred == y_test_bin).mean())
end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")
plt.plot(range(1,N+1), train_acc, label="Train")
plt.plot(range(1,N+1), test_acc, label="Test")
plt.xlabel("Itération")
plt.ylabel("Accuracy")
plt.title("Perceptron avec BoW (mode=freq)")
plt.legend()
plt.grid(True)
plt.show()
print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Temps total d'entraînement : 0.7543280124664307 secondes
Accuracy finale (train): 0.884393063583815 Accuracy finale (test) : 0.7110969387755102 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.9705882352941176), np.float64(0.9705882352941176), np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0)] Taux moyen de bonne classification : 0.9824 Écart-type : 0.0144
# =================================================================
# Classification binaire avec TF-IDF avec PerceptronBiais - Version 5
# =================================================================
# Cette version utilise le score TF-IDF comme caractéristiques
classe1 = 0
classe2 = 1
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle TF-IDF
# TF-IDF pondère les mots par leur importance dans le document et le corpus
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
perceptron = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=0.01)
N = 100
train_acc, test_acc = [], []
# Chronométrer l'entraînement
start = time.time()
for _ in range(N):
perceptron.train_step(X_train, y_train_bin)
y_train_pred = np.array([perceptron.predict(x) for x in X_train])
y_test_pred = np.array([perceptron.predict(x) for x in X_test])
train_acc.append((y_train_pred == y_train_bin).mean())
test_acc.append((y_test_pred == y_test_bin).mean())
end = time.time()
print("Temps total d'entraînement :", end - start, "secondes")
plt.plot(range(1,N+1), train_acc, label="Train")
plt.plot(range(1,N+1), test_acc, label="Test")
plt.xlabel("Itération")
plt.ylabel("Accuracy")
plt.title("Perceptron avec BoW (mode=tfidf)")
plt.legend()
plt.grid(True)
plt.show()
print("Accuracy finale (train):", train_acc[-1])
print("Accuracy finale (test) :", test_acc[-1])
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(perceptron, (X_train_bin, y_train_bin), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Temps total d'entraînement : 0.7282757759094238 secondes
Accuracy finale (train): 0.9942196531791907 Accuracy finale (test) : 0.9177295918367347 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 1.0000 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0), np.float64(0.9705882352941176), np.float64(1.0)] Taux moyen de bonne classification : 0.9882 Écart-type : 0.0144
# =================================================================
# Classification multi-classe avec (Bag-of-Words binary) avec PerceptronBiais - Version 1
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "binary" # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)
learning_rate = 0.01
N = 100 # Nombre d'itérations pour le perceptronbiais
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle Multi-classe (OAA)
# ---------------------------
# Initialisation du classifieur de base (PerceptronBiais)
perceptron_base = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=learning_rate)
# Construction du classifieur multi-classe OAA
oaa_classifier = classif.ClassifierMultiOAA(perceptron_base)
# Chronométrage
start = time.time()
oaa_classifier.train(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = np.array([oaa_classifier.predict(x) for x in X_train])
y_test_pred = np.array([oaa_classifier.predict(x) for x in X_test])
# ---------------------------
# Évaluation des performances
# ---------------------------
# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec (Bag-of-Words binary) avec PerceptronBiais")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
# Pour validation croisée, on réinitialise un modèle neuf
def create_new_oaa():
base = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=learning_rate)
return classif.ClassifierMultiOAA(base)
perf = []
for i in range(nb_folds):
Xapp, Yapp, Xtest, Ytest = ev.crossval_strat(X_train, y_train_multi, nb_folds, i)
clf = create_new_oaa()
clf.train(Xapp, Yapp)
Y_pred = np.array([clf.predict(x) for x in Xtest])
acc = np.mean(Y_pred == Ytest)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe) : 14.851285934448242 secondes Accuracy entraînement : 0.9891 Accuracy test : 0.4260
Itération 0: Accuracy = 0.4639 Itération 1: Accuracy = 0.4028 Itération 2: Accuracy = 0.3833 Itération 3: Accuracy = 0.3889 Itération 4: Accuracy = 0.4278 Taux moyen : 0.4133, Écart-type : 0.0296
# =================================================================
# Classification multi-classe avec (Bag-of-Words comptage) avec PerceptronBiais - Version 2
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "count" # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)
learning_rate = 0.01
N = 100 # Nombre d'itérations pour le perceptronbiais
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
# Passage en dense + normalisation log(1 + x)
X_train = np.log1p(X_train_sparse.toarray())
X_test = np.log1p(X_test_sparse.toarray())
# ---------------------------
# Entraînement du modèle Multi-classe (OAA)
# ---------------------------
# Initialisation du classifieur de base (PerceptronBiais)
perceptron_base = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=learning_rate)
# Construction du classifieur multi-classe OAA
oaa_classifier = classif.ClassifierMultiOAA(perceptron_base)
# Chronométrage
start = time.time()
oaa_classifier.train(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = np.array([oaa_classifier.predict(x) for x in X_train])
y_test_pred = np.array([oaa_classifier.predict(x) for x in X_test])
# ---------------------------
# Évaluation des performances
# ---------------------------
# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec (Bag-of-Words comptage) avec PerceptronBiais")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
# Pour validation croisée, on réinitialise un modèle neuf
def create_new_oaa():
base = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=learning_rate)
return classif.ClassifierMultiOAA(base)
perf = []
for i in range(nb_folds):
Xapp, Yapp, Xtest, Ytest = ev.crossval_strat(X_train, y_train_multi, nb_folds, i)
clf = create_new_oaa()
clf.train(Xapp, Yapp)
Y_pred = np.array([clf.predict(x) for x in Xtest])
acc = np.mean(Y_pred == Ytest)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe) : 15.709067106246948 secondes Accuracy entraînement : 0.9891 Accuracy test : 0.4524
Itération 0: Accuracy = 0.4528 Itération 1: Accuracy = 0.4333 Itération 2: Accuracy = 0.4028 Itération 3: Accuracy = 0.4111 Itération 4: Accuracy = 0.4278 Taux moyen : 0.4256, Écart-type : 0.0175
# =================================================================
# Classification multi-classe avec (Bag-of-Words frequence) avec PerceptronBiais - Version 3
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "freq" # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)
learning_rate = 0.01
N = 100 # Nombre d'itérations pour le perceptronbiais
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
# Passage en dense
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# L2-normalisation manuelle
def l2_normalize(X):
norms = np.linalg.norm(X, axis=1, keepdims=True)
norms[norms == 0] = 1
return X / norms
X_train = l2_normalize(X_train)
X_test = l2_normalize(X_test)
# ---------------------------
# Entraînement du modèle Multi-classe (OAA)
# ---------------------------
# Initialisation du classifieur de base (PerceptronBiais)
perceptron_base = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=learning_rate)
# Construction du classifieur multi-classe OAA
oaa_classifier = classif.ClassifierMultiOAA(perceptron_base)
# Chronométrage
start = time.time()
oaa_classifier.train(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = np.array([oaa_classifier.predict(x) for x in X_train])
y_test_pred = np.array([oaa_classifier.predict(x) for x in X_test])
# ---------------------------
# Évaluation des performances
# ---------------------------
# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec (Bag-of-Words frequence) avec PerceptronBiais")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
# Pour validation croisée, on réinitialise un modèle neuf
def create_new_oaa():
base = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=learning_rate)
return classif.ClassifierMultiOAA(base)
perf = []
for i in range(nb_folds):
Xapp, Yapp, Xtest, Ytest = ev.crossval_strat(X_train, y_train_multi, nb_folds, i)
clf = create_new_oaa()
clf.train(Xapp, Yapp)
Y_pred = np.array([clf.predict(x) for x in Xtest])
acc = np.mean(Y_pred == Ytest)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe) : 22.410446166992188 secondes Accuracy entraînement : 0.9815 Accuracy test : 0.5198
Itération 0: Accuracy = 0.5167 Itération 1: Accuracy = 0.5139 Itération 2: Accuracy = 0.4944 Itération 3: Accuracy = 0.4861 Itération 4: Accuracy = 0.5111 Taux moyen : 0.5044, Écart-type : 0.0120
# =================================================================
# Classification multi-classe avec (Bag-of-Words tf-idf) avec PerceptronBiais - Version 4
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
learning_rate = 0.01
N = 100 # Nombre d'itérations pour le perceptronbiais
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle Multi-classe (OAA)
# ---------------------------
# Initialisation du classifieur de base (PerceptronBiais)
perceptron_base = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=learning_rate)
# Construction du classifieur multi-classe OAA
oaa_classifier = classif.ClassifierMultiOAA(perceptron_base)
# Chronométrage
start = time.time()
oaa_classifier.train(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = np.array([oaa_classifier.predict(x) for x in X_train])
y_test_pred = np.array([oaa_classifier.predict(x) for x in X_test])
# ---------------------------
# Évaluation des performances
# ---------------------------
# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec (Bag-of-Words tf-idf) avec PerceptronBiais")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
# Pour validation croisée, on réinitialise un modèle neuf
def create_new_oaa():
base = classif.ClassifierPerceptronBiais(input_dimension=X_train.shape[1], learning_rate=learning_rate)
return classif.ClassifierMultiOAA(base)
perf = []
for i in range(nb_folds):
Xapp, Yapp, Xtest, Ytest = ev.crossval_strat(X_train, y_train_multi, nb_folds, i)
clf = create_new_oaa()
clf.train(Xapp, Yapp)
Y_pred = np.array([clf.predict(x) for x in Xtest])
acc = np.mean(Y_pred == Ytest)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe) : 24.897457122802734 secondes Accuracy entraînement : 0.9788 Accuracy test : 0.5675
Itération 0: Accuracy = 0.5667 Itération 1: Accuracy = 0.5361 Itération 2: Accuracy = 0.5583 Itération 3: Accuracy = 0.5444 Itération 4: Accuracy = 0.5861 Taux moyen : 0.5583, Écart-type : 0.0175
Classifier KNN avec distance euclidienne¶
K = 3
# =================================================================
# Classification binare avec (Bag-of-Words Binaire) avec KNN avec distance euclidienne (k = 3) - Version 1
# =================================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=3)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 2.79603 secondes Accuracy (train) : 0.9133 Accuracy (test) : 0.5236 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5000 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.6765 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.6176 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5000 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5000 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.5), np.float64(0.6764705882352942), np.float64(0.6176470588235294), np.float64(0.5), np.float64(0.5)] Taux moyen de bonne classification : 0.5588 Écart-type : 0.0744
# =================================================================
# Classification binare avec (Bag-of-Words Comptage) avec KNN avec distance euclidienne (k = 3) - Version 2
# =================================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=3)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 2.79690 secondes Accuracy (train) : 0.9306 Accuracy (test) : 0.6129 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5000 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.6471 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.7059 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5000 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.4706 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.5), np.float64(0.6470588235294118), np.float64(0.7058823529411765), np.float64(0.5), np.float64(0.47058823529411764)] Taux moyen de bonne classification : 0.5647 Écart-type : 0.0937
# =================================================================
# Classification binare avec (Bag-of-Words Frequence) avec KNN avec distance euclidienne (k = 3) - Version 3
# =================================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=3)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 2.80271 secondes Accuracy (train) : 0.9827 Accuracy (test) : 0.7577 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.7353 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.6176 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.6765 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.7941 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.7059 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.7352941176470589), np.float64(0.6176470588235294), np.float64(0.6764705882352942), np.float64(0.7941176470588235), np.float64(0.7058823529411765)] Taux moyen de bonne classification : 0.7059 Écart-type : 0.0588
# =================================================================
# Classification binare avec (Bag-of-Words TF-IDF) avec KNN avec distance euclidienne (k = 3) - Version 4
# =================================================================
# Définition des deux classes binaires
classe1 = 0
classe2 = 1
# Filtrage du dataset pour ne garder que les classes d'intérêt
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des cibles en -1 et +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Récupération des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Transformation en représentation TF-IDF manuelle
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=3)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 2.80374 secondes Accuracy (train) : 0.9942 Accuracy (test) : 0.8361 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8235 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.6471 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8824 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.7353 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8529 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.8235294117647058), np.float64(0.6470588235294118), np.float64(0.8823529411764706), np.float64(0.7352941176470589), np.float64(0.8529411764705882)] Taux moyen de bonne classification : 0.7882 Écart-type : 0.0861
# =================================================================
# Classification multi-classe avec (Bag-of-Words binary) avec KNN sklearn (k = 3) - Version 1
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "binary" # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------
knn_classifier = KNeighborsClassifier(n_neighbors=3, metric='euclidean')
start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) avec sklearn KNN :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)
# ---------------------------
# Évaluation des performances
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3)")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
clf = KNeighborsClassifier(n_neighbors=3, metric='euclidean')
clf.fit(Xapp, Yapp)
Y_pred = clf.predict(Xval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe) avec sklearn KNN : 0.007567167282104492 secondes Accuracy entraînement : 0.3252 Accuracy test : 0.0783
Itération 0: Accuracy = 0.0788 Itération 1: Accuracy = 0.0763 Itération 2: Accuracy = 0.0681 Itération 3: Accuracy = 0.0790 Itération 4: Accuracy = 0.0845 Taux moyen : 0.0773, Écart-type : 0.0053
# =================================================================
# Classification multi-classe avec (Bag-of-Words Comptage) avec KNN sklearn (k = 3) - Version 2
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "count" # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------
knn_classifier = KNeighborsClassifier(n_neighbors=3, metric='euclidean')
start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) avec sklearn KNN :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)
# ---------------------------
# Évaluation des performances
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3)")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
clf = KNeighborsClassifier(n_neighbors=3, metric='euclidean')
clf.fit(Xapp, Yapp)
Y_pred = clf.predict(Xval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe) avec sklearn KNN : 0.01612067222595215 secondes Accuracy entraînement : 0.3883 Accuracy test : 0.1278
Itération 0: Accuracy = 0.1005 Itération 1: Accuracy = 0.0981 Itération 2: Accuracy = 0.1199 Itération 3: Accuracy = 0.1281 Itération 4: Accuracy = 0.1444 Taux moyen : 0.1182, Écart-type : 0.0173
# =================================================================
# Classification multi-classe avec (Bag-of-Words Frequence) avec KNN sklearn (k = 3) - Version 3
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "freq" # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------
knn_classifier = KNeighborsClassifier(n_neighbors=3, metric='euclidean')
start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) avec sklearn KNN :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)
# ---------------------------
# Évaluation des performances
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3)")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
clf = KNeighborsClassifier(n_neighbors=3, metric='euclidean')
clf.fit(Xapp, Yapp)
Y_pred = clf.predict(Xval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe) avec sklearn KNN : 0.01175999641418457 secondes Accuracy entraînement : 0.3617 Accuracy test : 0.1158
Itération 0: Accuracy = 0.1250 Itération 1: Accuracy = 0.0954 Itération 2: Accuracy = 0.1281 Itération 3: Accuracy = 0.1008 Itération 4: Accuracy = 0.0872 Taux moyen : 0.1073, Écart-type : 0.0163
# =================================================================
# Classification multi-classe avec (Bag-of-Words tf-idf) avec sklearn KNN (k = 3) - Version 4
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
k = 3
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation TF-IDF
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------
knn_classifier = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe avec sklearn KNN) :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)
# ---------------------------
# Évaluation des performances
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3, TF-IDF)")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
clf = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
clf.fit(Xapp, Yapp)
Y_pred = clf.predict(Xval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe avec sklearn KNN) : 0.008476972579956055 secondes Accuracy entraînement : 0.3203 Accuracy test : 0.0981
Itération 0: Accuracy = 0.0815 Itération 1: Accuracy = 0.0763 Itération 2: Accuracy = 0.0845 Itération 3: Accuracy = 0.0926 Itération 4: Accuracy = 0.0845 Taux moyen : 0.0839, Écart-type : 0.0053
k = 5
# =================================================================
# Classification binare avec (Bag-of-Words Binaire) avec KNN avec distance euclidienne (k = 5) - Version 1
# =================================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=5)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 2.83509 secondes Accuracy (train) : 0.7803 Accuracy (test) : 0.5485 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.4412 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.6765 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5882 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.6176 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5000 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.4411764705882353), np.float64(0.6764705882352942), np.float64(0.5882352941176471), np.float64(0.6176470588235294), np.float64(0.5)] Taux moyen de bonne classification : 0.5647 Écart-type : 0.0840
# =================================================================
# Classification binare avec (Bag-of-Words Comptage) avec KNN avec distance euclidienne (k = 5) - Version 2
# =================================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=5)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 2.96515 secondes Accuracy (train) : 0.7919 Accuracy (test) : 0.5784 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5000 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.6471 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.6765 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.6176 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.5), np.float64(0.6470588235294118), np.float64(0.6764705882352942), np.float64(0.6176470588235294), np.float64(0.5588235294117647)] Taux moyen de bonne classification : 0.6000 Écart-type : 0.0634
# =================================================================
# Classification binare avec (Bag-of-Words Frequence) avec KNN avec distance euclidienne (k = 5) - Version 3
# =================================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=5)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 3.16788 secondes Accuracy (train) : 0.8960 Accuracy (test) : 0.6849 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5294 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5294 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5294 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.6765 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.5294117647058824), np.float64(0.5294117647058824), np.float64(0.5294117647058824), np.float64(0.5588235294117647), np.float64(0.6764705882352942)] Taux moyen de bonne classification : 0.5647 Écart-type : 0.0570
# =================================================================
# Classification binare avec (Bag-of-Words TF-IDF) avec KNN avec distance euclidienne (k = 5) - Version 4
# =================================================================
# Définition des deux classes binaires
classe1 = 0
classe2 = 1
# Filtrage du dataset pour ne garder que les classes d'intérêt
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des cibles en -1 et +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Récupération des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Transformation en représentation TF-IDF manuelle
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=5)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 3.26109 secondes Accuracy (train) : 0.9653 Accuracy (test) : 0.6818 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5294 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5000 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.6765 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.4706 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.7059 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.5294117647058824), np.float64(0.5), np.float64(0.6764705882352942), np.float64(0.47058823529411764), np.float64(0.7058823529411765)] Taux moyen de bonne classification : 0.5765 Écart-type : 0.0959
# =================================================================
# Classification multi-classe avec (Bag-of-Words binary) avec KNN sklearn (k = 5) - Version 1
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "binary" # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------
knn_classifier = KNeighborsClassifier(n_neighbors=5, metric='euclidean')
start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) avec sklearn KNN :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)
# ---------------------------
# Évaluation des performances
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3)")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
clf = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
clf.fit(Xapp, Yapp)
Y_pred = clf.predict(Xval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe) avec sklearn KNN : 0.008249759674072266 secondes Accuracy entraînement : 0.2435 Accuracy test : 0.0752
Itération 0: Accuracy = 0.0788 Itération 1: Accuracy = 0.0763 Itération 2: Accuracy = 0.0681 Itération 3: Accuracy = 0.0790 Itération 4: Accuracy = 0.0845 Taux moyen : 0.0773, Écart-type : 0.0053
# =================================================================
# Classification multi-classe avec (Bag-of-Words Comptage) avec KNN sklearn (k = 5) - Version 2
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "count" # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------
knn_classifier = KNeighborsClassifier(n_neighbors=5, metric='euclidean')
start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) avec sklearn KNN :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)
# ---------------------------
# Évaluation des performances
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3)")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
clf = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
clf.fit(Xapp, Yapp)
Y_pred = clf.predict(Xval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe) avec sklearn KNN : 0.007130146026611328 secondes Accuracy entraînement : 0.3110 Accuracy test : 0.1286
Itération 0: Accuracy = 0.1005 Itération 1: Accuracy = 0.0981 Itération 2: Accuracy = 0.1199 Itération 3: Accuracy = 0.1281 Itération 4: Accuracy = 0.1444 Taux moyen : 0.1182, Écart-type : 0.0173
# =================================================================
# Classification multi-classe avec (Bag-of-Words Frequence) avec KNN sklearn (k = 5) - Version 3
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "freq" # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------
knn_classifier = KNeighborsClassifier(n_neighbors=5, metric='euclidean')
start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) avec sklearn KNN :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)
# ---------------------------
# Évaluation des performances
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3)")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
clf = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
clf.fit(Xapp, Yapp)
Y_pred = clf.predict(Xval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe) avec sklearn KNN : 0.010577917098999023 secondes Accuracy entraînement : 0.2342 Accuracy test : 0.0981
Itération 0: Accuracy = 0.1250 Itération 1: Accuracy = 0.0954 Itération 2: Accuracy = 0.1281 Itération 3: Accuracy = 0.1008 Itération 4: Accuracy = 0.0872 Taux moyen : 0.1073, Écart-type : 0.0163
# =================================================================
# Classification multi-classe avec (Bag-of-Words tf-idf) avec sklearn KNN (k = 5) - Version 4
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
k = 5
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation TF-IDF
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------
knn_classifier = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe avec sklearn KNN) :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)
# ---------------------------
# Évaluation des performances
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3, TF-IDF)")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
clf = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
clf.fit(Xapp, Yapp)
Y_pred = clf.predict(Xval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe avec sklearn KNN) : 0.009913921356201172 secondes Accuracy entraînement : 0.1699 Accuracy test : 0.0780
Itération 0: Accuracy = 0.0707 Itération 1: Accuracy = 0.0708 Itération 2: Accuracy = 0.0708 Itération 3: Accuracy = 0.0981 Itération 4: Accuracy = 0.0736 Taux moyen : 0.0768, Écart-type : 0.0107
k = sqrt(taille de dataset)
k = math.sqrt(len(newsgroups_df_neitoie))
k
135.88966112254457
# =================================================================
# Classification binare avec (Bag-of-Words Binaire) avec KNN avec distance euclidienne (k = 135) - Version 1
# =================================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=135)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00003 secondes Prédiction sur test effectuée en 3.18741 secondes Accuracy (train) : 0.5491 Accuracy (test) : 0.5510 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647)] Taux moyen de bonne classification : 0.5588 Écart-type : 0.0000
# =================================================================
# Classification binare avec (Bag-of-Words Comptage) avec KNN avec distance euclidienne (k = 135) - Version 2
# =================================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=135)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 3.16653 secondes Accuracy (train) : 0.5491 Accuracy (test) : 0.5517 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647)] Taux moyen de bonne classification : 0.5588 Écart-type : 0.0000
# =================================================================
# Classification binare avec (Bag-of-Words Frequence) avec KNN avec distance euclidienne (k = 135) - Version 3
# =================================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=135)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 3.08743 secondes Accuracy (train) : 0.5491 Accuracy (test) : 0.5491 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647)] Taux moyen de bonne classification : 0.5588 Écart-type : 0.0000
# =================================================================
# Classification binare avec (Bag-of-Words TF-IDF) avec KNN avec distance euclidienne (k = 135) - Version 4
# =================================================================
# Définition des deux classes binaires
classe1 = 0
classe2 = 1
# Filtrage du dataset pour ne garder que les classes d'intérêt
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des cibles en -1 et +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Récupération des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Transformation en représentation TF-IDF manuelle
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNN(input_dimension=X_train.shape[1], k=135)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 3.05594 secondes Accuracy (train) : 0.5491 Accuracy (test) : 0.5491 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647)] Taux moyen de bonne classification : 0.5588 Écart-type : 0.0000
# =================================================================
# Classification multi-classe avec (Bag-of-Words binary) avec KNN sklearn (k = 135) - Version 1
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "binary" # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)
k = 135
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------
knn_classifier = KNeighborsClassifier(n_neighbors=135, metric='euclidean')
start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) avec sklearn KNN :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)
# ---------------------------
# Évaluation des performances
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3)")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
clf = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
clf.fit(Xapp, Yapp)
Y_pred = clf.predict(Xval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe) avec sklearn KNN : 0.01529693603515625 secondes Accuracy entraînement : 0.0719 Accuracy test : 0.0633
Itération 0: Accuracy = 0.0679 Itération 1: Accuracy = 0.0926 Itération 2: Accuracy = 0.0899 Itération 3: Accuracy = 0.0627 Itération 4: Accuracy = 0.0572 Taux moyen : 0.0741, Écart-type : 0.0145
# =================================================================
# Classification multi-classe avec (Bag-of-Words Comptage) avec KNN sklearn (k = 135) - Version 2
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "count" # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)
k = 135
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------
knn_classifier = KNeighborsClassifier(n_neighbors=135, metric='euclidean')
start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) avec sklearn KNN :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)
# ---------------------------
# Évaluation des performances
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3)")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
clf = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
clf.fit(Xapp, Yapp)
Y_pred = clf.predict(Xval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe) avec sklearn KNN : 0.017328977584838867 secondes Accuracy entraînement : 0.1198 Accuracy test : 0.0977
Itération 0: Accuracy = 0.0707 Itération 1: Accuracy = 0.1035 Itération 2: Accuracy = 0.0981 Itération 3: Accuracy = 0.0817 Itération 4: Accuracy = 0.0845 Taux moyen : 0.0877, Écart-type : 0.0118
# =================================================================
# Classification multi-classe avec (Bag-of-Words Frequence) avec KNN sklearn (k = 135) - Version 3
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "freq" # "binary", "count", "freq", "tfidf" (fonction bag_of_words_tfidf_manual)
k = 135
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------
knn_classifier = KNeighborsClassifier(n_neighbors=135, metric='euclidean')
start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe) avec sklearn KNN :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)
# ---------------------------
# Évaluation des performances
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3)")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
clf = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
clf.fit(Xapp, Yapp)
Y_pred = clf.predict(Xval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe) avec sklearn KNN : 0.013354063034057617 secondes Accuracy entraînement : 0.0910 Accuracy test : 0.0732
Itération 0: Accuracy = 0.0625 Itération 1: Accuracy = 0.0572 Itération 2: Accuracy = 0.0708 Itération 3: Accuracy = 0.0599 Itération 4: Accuracy = 0.0599 Taux moyen : 0.0621, Écart-type : 0.0047
# =================================================================
# Classification multi-classe avec (Bag-of-Words tf-idf) avec sklearn KNN (k = 135) - Version 4
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
k = 135
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation TF-IDF
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle Multi-classe avec sklearn KNN
# ---------------------------
knn_classifier = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
start = time.time()
knn_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe avec sklearn KNN) :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn_classifier.predict(X_train)
y_test_pred = knn_classifier.predict(X_test)
# ---------------------------
# Évaluation des performances
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Classification multi-classe avec sklearn KNN (k = 3, TF-IDF)")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sur train)
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
clf = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
clf.fit(Xapp, Yapp)
Y_pred = clf.predict(Xval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (multi-classe avec sklearn KNN) : 0.017281770706176758 secondes Accuracy entraînement : 0.1155 Accuracy test : 0.0873
Itération 0: Accuracy = 0.0543 Itération 1: Accuracy = 0.0572 Itération 2: Accuracy = 0.0845 Itération 3: Accuracy = 0.0654 Itération 4: Accuracy = 0.0572 Taux moyen : 0.0637, Écart-type : 0.0110
Classifier KNN avec distance cosinus¶
# =================================================================
# Classification binare avec (Bag-of-Words Binaire) avec KNN avec distance cosinus (k = 3) - Version 1
# =================================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=3)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 1.33372 secondes Accuracy (train) : 0.9191 Accuracy (test) : 0.8323 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8824 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9412 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8529 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8529 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.7941 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.8823529411764706), np.float64(0.9411764705882353), np.float64(0.8529411764705882), np.float64(0.8529411764705882), np.float64(0.7941176470588235)] Taux moyen de bonne classification : 0.8647 Écart-type : 0.0478
# =================================================================
# Classification binare avec (Bag-of-Words Comptage) avec KNN avec distance cosinus (k = 3) - Version 2
# =================================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=3)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 1.31408 secondes Accuracy (train) : 0.9133 Accuracy (test) : 0.8629 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8824 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8824 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8529 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8529 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.7941 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.8823529411764706), np.float64(0.8823529411764706), np.float64(0.8529411764705882), np.float64(0.8529411764705882), np.float64(0.7941176470588235)] Taux moyen de bonne classification : 0.8529 Écart-type : 0.0322
# =================================================================
# Classification binare avec (Bag-of-Words Frequence) avec KNN avec distance cosinus (k = 3) - Version 3
# =================================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=3)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 1.28902 secondes Accuracy (train) : 0.9133 Accuracy (test) : 0.8622 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8824 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8824 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8529 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8529 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.7941 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.8823529411764706), np.float64(0.8823529411764706), np.float64(0.8529411764705882), np.float64(0.8529411764705882), np.float64(0.7941176470588235)] Taux moyen de bonne classification : 0.8529 Écart-type : 0.0322
# =================================================================
# Classification binare avec (Bag-of-Words TF-IDF) avec KNN avec distance cosinus (k = 3) - Version 4
# =================================================================
# Définition des deux classes binaires
classe1 = 0
classe2 = 1
# Filtrage du dataset pour ne garder que les classes d'intérêt
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des cibles en -1 et +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Récupération des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Transformation en représentation TF-IDF manuelle
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=3)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 1.44204 secondes Accuracy (train) : 0.9480 Accuracy (test) : 0.8807 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9412 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9412 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8529 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8824 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8529 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.9411764705882353), np.float64(0.9411764705882353), np.float64(0.8529411764705882), np.float64(0.8823529411764706), np.float64(0.8529411764705882)] Taux moyen de bonne classification : 0.8941 Écart-type : 0.0399
# =================================================================
# Classification multi-classe avec (Bag-of-Words binary) avec sklearn KNN (cosine distance, k=3) - Version 1
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "binary"
k = 3
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
D_train = cosine_distances(X_train)
knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (avec sklearn + cosine distance) :", end - start, "secondes")
D_test = cosine_distances(X_test, X_train)
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)
# ---------------------------
# Évaluation
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
Dapp = cosine_distances(Xapp)
Dval = cosine_distances(Xval, Xapp)
clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
clf.fit(Dapp, Yapp)
Y_pred = clf.predict(Dval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (avec sklearn + cosine distance) : 0.003222942352294922 secondes Accuracy entraînement : 0.5501 Accuracy test : 0.2569
Itération 0: Accuracy = 0.2609 Itération 1: Accuracy = 0.2316 Itération 2: Accuracy = 0.2316 Itération 3: Accuracy = 0.3025 Itération 4: Accuracy = 0.2289 Taux moyen : 0.2511, Écart-type : 0.0282
# =================================================================
# Classification multi-classe avec (Bag-of-Words comptage) avec sklearn KNN (cosine distance, k=3) - Version 2
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "count"
k = 3
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
D_train = cosine_distances(X_train)
knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (avec sklearn + cosine distance) :", end - start, "secondes")
D_test = cosine_distances(X_test, X_train)
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)
# ---------------------------
# Évaluation
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
Dapp = cosine_distances(Xapp)
Dval = cosine_distances(Xval, Xapp)
clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
clf.fit(Dapp, Yapp)
Y_pred = clf.predict(Dval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (avec sklearn + cosine distance) : 0.002089977264404297 secondes Accuracy entraînement : 0.5561 Accuracy test : 0.3004
Itération 0: Accuracy = 0.2799 Itération 1: Accuracy = 0.2725 Itération 2: Accuracy = 0.2807 Itération 3: Accuracy = 0.2616 Itération 4: Accuracy = 0.2861 Taux moyen : 0.2761, Écart-type : 0.0085
# =================================================================
# Classification multi-classe avec (Bag-of-Words Frequence) avec sklearn KNN (cosine distance, k=3) - Version 3
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "freq"
k = 3
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
D_train = cosine_distances(X_train)
knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (avec sklearn + cosine distance) :", end - start, "secondes")
D_test = cosine_distances(X_test, X_train)
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)
# ---------------------------
# Évaluation
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
Dapp = cosine_distances(Xapp)
Dval = cosine_distances(Xval, Xapp)
clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
clf.fit(Dapp, Yapp)
Y_pred = clf.predict(Dval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (avec sklearn + cosine distance) : 0.0019378662109375 secondes Accuracy entraînement : 0.5561 Accuracy test : 0.3004
Itération 0: Accuracy = 0.2799 Itération 1: Accuracy = 0.2725 Itération 2: Accuracy = 0.2807 Itération 3: Accuracy = 0.2616 Itération 4: Accuracy = 0.2861 Taux moyen : 0.2761, Écart-type : 0.0085
# =================================================================
# Classification multi-classe avec (Bag-of-Words TF-IDF) avec sklearn KNN (cosine distance, k=3) - Version 4
# =================================================================
# ---------------------------
# Paramètres
# ---------------------------
k = 3
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# TF-IDF vectorisation (manuelle)
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement sklearn KNN avec distance cosinus
# ---------------------------
D_train = cosine_distances(X_train)
knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (sklearn + cosine distance) :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
D_test = cosine_distances(X_test, X_train) # distance test vs train
y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)
# ---------------------------
# Évaluation
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus (TF-IDF)")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (Stratifiée)
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
Dapp = cosine_distances(Xapp)
Dval = cosine_distances(Xval, Xapp)
clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
clf.fit(Dapp, Yapp)
Y_pred = clf.predict(Dval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (sklearn + cosine distance) : 0.0018210411071777344 secondes Accuracy entraînement : 0.6389 Accuracy test : 0.3996
Itération 0: Accuracy = 0.3668 Itération 1: Accuracy = 0.3324 Itération 2: Accuracy = 0.3924 Itération 3: Accuracy = 0.3842 Itération 4: Accuracy = 0.3924 Taux moyen : 0.3736, Écart-type : 0.0226
k = 5
# =================================================================
# Classification binare avec (Bag-of-Words Binaire) avec KNN avec distance cosinus (k = 5) - Version 1
# =================================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=5)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 1.32580 secondes Accuracy (train) : 0.9133 Accuracy (test) : 0.8469 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8824 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8529 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.7941 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8824 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.7941 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.8823529411764706), np.float64(0.8529411764705882), np.float64(0.7941176470588235), np.float64(0.8823529411764706), np.float64(0.7941176470588235)] Taux moyen de bonne classification : 0.8412 Écart-type : 0.0399
# =================================================================
# Classification binare avec (Bag-of-Words Comptage) avec KNN avec distance cosinus (k = 5) - Version 2
# =================================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=5)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 1.31347 secondes Accuracy (train) : 0.9191 Accuracy (test) : 0.8661 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9118 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8529 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.7941 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8824 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8529 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.9117647058823529), np.float64(0.8529411764705882), np.float64(0.7941176470588235), np.float64(0.8823529411764706), np.float64(0.8529411764705882)] Taux moyen de bonne classification : 0.8588 Écart-type : 0.0390
# =================================================================
# Classification binare avec (Bag-of-Words Frequence) avec KNN avec distance cosinus (k = 5) - Version 3
# =================================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=5)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00004 secondes Prédiction sur test effectuée en 1.29489 secondes Accuracy (train) : 0.9191 Accuracy (test) : 0.8654 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9118 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8529 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.7941 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8824 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8529 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.9117647058823529), np.float64(0.8529411764705882), np.float64(0.7941176470588235), np.float64(0.8823529411764706), np.float64(0.8529411764705882)] Taux moyen de bonne classification : 0.8588 Écart-type : 0.0390
# =================================================================
# Classification binare avec (Bag-of-Words TF-IDF) avec KNN avec distance cosinus (k = 5) - Version 4
# =================================================================
# Définition des deux classes binaires
classe1 = 0
classe2 = 1
# Filtrage du dataset pour ne garder que les classes d'intérêt
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des cibles en -1 et +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Récupération des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Transformation en représentation TF-IDF manuelle
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=5)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 1.30947 secondes Accuracy (train) : 0.9480 Accuracy (test) : 0.8884 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8824 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9706 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8824 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.9412 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.8529 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.8823529411764706), np.float64(0.9705882352941176), np.float64(0.8823529411764706), np.float64(0.9411764705882353), np.float64(0.8529411764705882)] Taux moyen de bonne classification : 0.9059 Écart-type : 0.0432
# =================================================================
# Classification multi-classe avec (Bag-of-Words binary) avec sklearn KNN (cosine distance, k=5) - Version 1
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "binary"
k = 5
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
D_train = cosine_distances(X_train)
knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (avec sklearn + cosine distance) :", end - start, "secondes")
D_test = cosine_distances(X_test, X_train)
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)
# ---------------------------
# Évaluation
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
Dapp = cosine_distances(Xapp)
Dval = cosine_distances(Xval, Xapp)
clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
clf.fit(Dapp, Yapp)
Y_pred = clf.predict(Dval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (avec sklearn + cosine distance) : 0.0022890567779541016 secondes Accuracy entraînement : 0.5349 Accuracy test : 0.2896
Itération 0: Accuracy = 0.2989 Itération 1: Accuracy = 0.2589 Itération 2: Accuracy = 0.2807 Itération 3: Accuracy = 0.3079 Itération 4: Accuracy = 0.2807 Taux moyen : 0.2854, Écart-type : 0.0170
# =================================================================
# Classification multi-classe avec (Bag-of-Words Comptage) avec sklearn KNN (cosine distance, k=5) - Version 2
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "count"
k = 5
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
D_train = cosine_distances(X_train)
knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (avec sklearn + cosine distance) :", end - start, "secondes")
D_test = cosine_distances(X_test, X_train)
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)
# ---------------------------
# Évaluation
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
Dapp = cosine_distances(Xapp)
Dval = cosine_distances(Xval, Xapp)
clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
clf.fit(Dapp, Yapp)
Y_pred = clf.predict(Dval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (avec sklearn + cosine distance) : 0.00215911865234375 secondes Accuracy entraînement : 0.5664 Accuracy test : 0.3333
Itération 0: Accuracy = 0.3043 Itération 1: Accuracy = 0.3106 Itération 2: Accuracy = 0.3161 Itération 3: Accuracy = 0.3243 Itération 4: Accuracy = 0.3161 Taux moyen : 0.3143, Écart-type : 0.0066
# =================================================================
# Classification multi-classe avec (Bag-of-Words Frequence) avec sklearn KNN (cosine distance, k=5) - Version 3
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "freq"
k = 5
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
D_train = cosine_distances(X_train)
knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (avec sklearn + cosine distance) :", end - start, "secondes")
D_test = cosine_distances(X_test, X_train)
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)
# ---------------------------
# Évaluation
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
Dapp = cosine_distances(Xapp)
Dval = cosine_distances(Xval, Xapp)
clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
clf.fit(Dapp, Yapp)
Y_pred = clf.predict(Dval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (avec sklearn + cosine distance) : 0.00177001953125 secondes Accuracy entraînement : 0.5670 Accuracy test : 0.3332
Itération 0: Accuracy = 0.3043 Itération 1: Accuracy = 0.3106 Itération 2: Accuracy = 0.3161 Itération 3: Accuracy = 0.3270 Itération 4: Accuracy = 0.3161 Taux moyen : 0.3148, Écart-type : 0.0075
# =================================================================
# Classification multi-classe avec (Bag-of-Words TF-IDF) avec sklearn KNN (cosine distance, k=5) - Version 4
# =================================================================
# ---------------------------
# Paramètres
# ---------------------------
k = 5
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# TF-IDF vectorisation (manuelle)
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement sklearn KNN avec distance cosinus
# ---------------------------
D_train = cosine_distances(X_train)
knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (sklearn + cosine distance) :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
D_test = cosine_distances(X_test, X_train) # distance test vs train
y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)
# ---------------------------
# Évaluation
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus (TF-IDF)")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (Stratifiée)
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
Dapp = cosine_distances(Xapp)
Dval = cosine_distances(Xval, Xapp)
clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
clf.fit(Dapp, Yapp)
Y_pred = clf.predict(Dval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (sklearn + cosine distance) : 0.0019829273223876953 secondes Accuracy entraînement : 0.6275 Accuracy test : 0.4408
Itération 0: Accuracy = 0.4484 Itération 1: Accuracy = 0.4060 Itération 2: Accuracy = 0.4223 Itération 3: Accuracy = 0.4251 Itération 4: Accuracy = 0.4114 Taux moyen : 0.4226, Écart-type : 0.0146
k = 135
# =================================================================
# Classification binare avec (Bag-of-Words Binaire) avec KNN avec distance cosinus (k = 135) - Version 1
# =================================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=135)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 1.39356 secondes Accuracy (train) : 0.5954 Accuracy (test) : 0.5778 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647)] Taux moyen de bonne classification : 0.5588 Écart-type : 0.0000
# =================================================================
# Classification binare avec (Bag-of-Words Comptage) avec KNN avec distance cosinus (k = 135) - Version 2
# =================================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=135)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 1.27433 secondes Accuracy (train) : 0.5954 Accuracy (test) : 0.5759 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647)] Taux moyen de bonne classification : 0.5588 Écart-type : 0.0000
# =================================================================
# Classification binare avec (Bag-of-Words Frequence) avec KNN avec distance cosinus (k = 135) - Version 3
# =================================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en -1 / +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec modèle Bag-of-Words en mode binaire
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")
# Conversion des matrices creuses en tableaux denses
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=135)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 1.28890 secondes Accuracy (train) : 0.5954 Accuracy (test) : 0.5765 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647)] Taux moyen de bonne classification : 0.5588 Écart-type : 0.0000
# =================================================================
# Classification binare avec (Bag-of-Words TF-IDF) avec KNN avec distance cosinus (k = 135) - Version 4
# =================================================================
# Définition des deux classes binaires
classe1 = 0
classe2 = 1
# Filtrage du dataset pour ne garder que les classes d'intérêt
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des cibles en -1 et +1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: -1 if x == classe1 else +1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: -1 if x == classe1 else +1)
# Récupération des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Transformation en représentation TF-IDF manuelle
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# Extraction des étiquettes binaires
y_train = df_binaire["target_bin"].to_numpy()
y_test = df_test_bin["target_bin"].to_numpy()
# Initialisation du classificateur KNN
knn = classif.ClassifierKNNCosine(input_dimension=X_train.shape[1], k=135)
# Entraînement
tic = time.time()
knn.train(X_train, y_train)
toc = time.time()
print(f"Apprentissage effectué en {(toc - tic):.5f} secondes")
# Prédiction sur test
tic = time.time()
y_pred = np.array([knn.predict(x) for x in X_test])
toc = time.time()
print(f"Prédiction sur test effectuée en {(toc - tic):.5f} secondes")
# Prédiction sur train
y_pred_train = np.array([knn.predict(x) for x in X_train])
accuracy_train = np.mean(y_pred_train == y_train)
print(f"Accuracy (train) : {accuracy_train:.4f}")
# Évaluation sur test
accuracy = np.mean(y_pred == y_test)
print(f"Accuracy (test) : {accuracy:.4f}")
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(knn, (X_train, y_train), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# ==== Matrice de confusion ====
cm = confusion_matrix(y_test, y_pred, labels=[-1, +1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Classe 0", "Classe 1"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion")
plt.show()
Apprentissage effectué en 0.00002 secondes Prédiction sur test effectuée en 1.37608 secondes Accuracy (train) : 0.6012 Accuracy (test) : 0.5848 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5588 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647), np.float64(0.5588235294117647)] Taux moyen de bonne classification : 0.5588 Écart-type : 0.0000
# =================================================================
# Classification multi-classe avec (Bag-of-Words Binaire) avec sklearn KNN (cosine distance, k=135) - Version 1
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "binary"
k = 135
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
D_train = cosine_distances(X_train)
knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (avec sklearn + cosine distance) :", end - start, "secondes")
D_test = cosine_distances(X_test, X_train)
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)
# ---------------------------
# Évaluation
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
Dapp = cosine_distances(Xapp)
Dval = cosine_distances(Xval, Xapp)
clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
clf.fit(Dapp, Yapp)
Y_pred = clf.predict(Dval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (avec sklearn + cosine distance) : 0.0017940998077392578 secondes Accuracy entraînement : 0.4172 Accuracy test : 0.3843
Itération 0: Accuracy = 0.3533 Itération 1: Accuracy = 0.3651 Itération 2: Accuracy = 0.3569 Itération 3: Accuracy = 0.3406 Itération 4: Accuracy = 0.3787 Taux moyen : 0.3589, Écart-type : 0.0127
# =================================================================
# Classification multi-classe avec (Bag-of-Words Comptage) avec sklearn KNN (cosine distance, k=135) - Version 2
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "count"
k = 135
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
D_train = cosine_distances(X_train)
knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (avec sklearn + cosine distance) :", end - start, "secondes")
D_test = cosine_distances(X_test, X_train)
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)
# ---------------------------
# Évaluation
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
Dapp = cosine_distances(Xapp)
Dval = cosine_distances(Xval, Xapp)
clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
clf.fit(Dapp, Yapp)
Y_pred = clf.predict(Dval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (avec sklearn + cosine distance) : 0.0018076896667480469 secondes Accuracy entraînement : 0.4336 Accuracy test : 0.4026
Itération 0: Accuracy = 0.3967 Itération 1: Accuracy = 0.3760 Itération 2: Accuracy = 0.3842 Itération 3: Accuracy = 0.3978 Itération 4: Accuracy = 0.3760 Taux moyen : 0.3862, Écart-type : 0.0096
# =================================================================
# Classification multi-classe avec (Bag-of-Words Frequence) avec sklearn KNN (cosine distance, k=135) - Version 3
# =================================================================
# ---------------------------
# Paramètres du test
# ---------------------------
mode_vectorisation = "freq"
k = 135
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
D_train = cosine_distances(X_train)
knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (avec sklearn + cosine distance) :", end - start, "secondes")
D_test = cosine_distances(X_test, X_train)
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)
# ---------------------------
# Évaluation
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
Dapp = cosine_distances(Xapp)
Dval = cosine_distances(Xval, Xapp)
clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
clf.fit(Dapp, Yapp)
Y_pred = clf.predict(Dval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (avec sklearn + cosine distance) : 0.001825094223022461 secondes Accuracy entraînement : 0.4341 Accuracy test : 0.4025
Itération 0: Accuracy = 0.3967 Itération 1: Accuracy = 0.3760 Itération 2: Accuracy = 0.3842 Itération 3: Accuracy = 0.3978 Itération 4: Accuracy = 0.3760 Taux moyen : 0.3862, Écart-type : 0.0096
# =================================================================
# Classification multi-classe avec (Bag-of-Words TF-IDF) avec sklearn KNN (cosine distance, k=135) - Version 4
# =================================================================
# ---------------------------
# Paramètres
# ---------------------------
k = 135
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# TF-IDF vectorisation (manuelle)
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement sklearn KNN avec distance cosinus
# ---------------------------
D_train = cosine_distances(X_train)
knn = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
start = time.time()
knn.fit(D_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (sklearn + cosine distance) :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
D_test = cosine_distances(X_test, X_train) # distance test vs train
y_train_pred = knn.predict(D_train)
y_test_pred = knn.predict(D_test)
# ---------------------------
# Évaluation
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - sklearn KNN avec distance cosinus (TF-IDF)")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (Stratifiée)
# ---------------------------
skf = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=42)
perf = []
for i, (train_idx, test_idx) in enumerate(skf.split(X_train, y_train_multi)):
Xapp, Yapp = X_train[train_idx], y_train_multi[train_idx]
Xval, Yval = X_train[test_idx], y_train_multi[test_idx]
Dapp = cosine_distances(Xapp)
Dval = cosine_distances(Xval, Xapp)
clf = KNeighborsClassifier(n_neighbors=k, metric='precomputed')
clf.fit(Dapp, Yapp)
Y_pred = clf.predict(Dval)
acc = np.mean(Y_pred == Yval)
print(f"Itération {i}: Accuracy = {acc:.4f}")
perf.append(acc)
moyenne = np.mean(perf)
ecart_type = np.std(perf)
print(f"Taux moyen : {moyenne:.4f}, Écart-type : {ecart_type:.4f}")
Temps d'entraînement (sklearn + cosine distance) : 0.0019979476928710938 secondes Accuracy entraînement : 0.5310 Accuracy test : 0.4924
Itération 0: Accuracy = 0.4864 Itération 1: Accuracy = 0.4387 Itération 2: Accuracy = 0.5068 Itération 3: Accuracy = 0.4605 Itération 4: Accuracy = 0.4877 Taux moyen : 0.4760, Écart-type : 0.0238
Classifier Naive Bayes¶
# ======================================================
# Classification binaire avec Bag-of-Words (Binaire) avec Naive Bayes - Version 1
# ======================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en 0 et 1 (plus simple pour Naive Bayes)
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: 0 if x == classe1 else 1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: 0 if x == classe1 else 1)
y_train_bin = df_binaire['target_bin'].values
y_test_bin = df_test_bin['target_bin'].values
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec Bag-of-Words mode binaire (sparse)
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")
# Initialisation et entraînement du classifieur Naive Bayes
nb_classifier = classif.ClassifierNaiveBayesMultinomialBinary(input_dimension=len(index_mots), alpha=1.0)
start = time.time()
nb_classifier.train(X_train_sparse, y_train_bin)
end = time.time()
print("Temps d'entraînement:", end - start, "secondes")
# Prédictions
y_train_pred = nb_classifier.predict(X_train_sparse)
y_test_pred = nb_classifier.predict(X_test_sparse)
# Calcul des précisions
train_acc = (y_train_pred == y_train_bin).mean()
test_acc = (y_test_pred == y_test_bin).mean()
print("Accuracy finale (train):", train_acc)
print("Accuracy finale (test):", test_acc)
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(nb_classifier, (X_train_sparse, y_train_bin), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# Visualisation de la matrice de confusion
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[0,1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {classe1}", f"Classe {classe2}"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion - Naive Bayes binaire")
plt.show()
Temps d'entraînement: 0.0023260116577148438 secondes Accuracy finale (train): 0.9826589595375722 Accuracy finale (test): 0.920280612244898 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.4965 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5104 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.4965 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5104 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5035 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.49653979238754326), np.float64(0.5103806228373703), np.float64(0.49653979238754326), np.float64(0.5103806228373703), np.float64(0.5034602076124568)] Taux moyen de bonne classification : 0.5035 Écart-type : 0.0062
# ======================================================
# Classification binaire avec Bag-of-Words (Count) avec Naive Bayes - Version 2
# ======================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en 0 et 1 (plus simple pour Naive Bayes)
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: 0 if x == classe1 else 1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: 0 if x == classe1 else 1)
y_train_bin = df_binaire['target_bin'].values
y_test_bin = df_test_bin['target_bin'].values
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec Bag-of-Words mode count (sparse)
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")
# Initialisation et entraînement du classifieur Naive Bayes
nb_classifier = classif.ClassifierNaiveBayesMultinomialBinary(input_dimension=len(index_mots), alpha=1.0)
start = time.time()
nb_classifier.train(X_train_sparse, y_train_bin)
end = time.time()
print("Temps d'entraînement:", end - start, "secondes")
# Prédictions
y_train_pred = nb_classifier.predict(X_train_sparse)
y_test_pred = nb_classifier.predict(X_test_sparse)
# Calcul des précisions
train_acc = (y_train_pred == y_train_bin).mean()
test_acc = (y_test_pred == y_test_bin).mean()
print("Accuracy finale (train):", train_acc)
print("Accuracy finale (test):", test_acc)
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(nb_classifier, (X_train_sparse, y_train_bin), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# Visualisation de la matrice de confusion
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[0,1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {classe1}", f"Classe {classe2}"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion - Naive Bayes avec BoW (count)")
plt.show()
Temps d'entraînement: 0.0003299713134765625 secondes Accuracy finale (train): 0.9826589595375722 Accuracy finale (test): 0.9196428571428571 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5035 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5069 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5069 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5104 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5069 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.5034602076124568), np.float64(0.5069204152249135), np.float64(0.5069204152249135), np.float64(0.5103806228373703), np.float64(0.5069204152249135)] Taux moyen de bonne classification : 0.5069 Écart-type : 0.0022
# ======================================================
# Classification binaire avec Bag-of-Words (Frequence) avec Naive Bayes - Version 3
# ======================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en 0 et 1 (plus simple pour Naive Bayes)
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: 0 if x == classe1 else 1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: 0 if x == classe1 else 1)
y_train_bin = df_binaire['target_bin'].values
y_test_bin = df_test_bin['target_bin'].values
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation avec Bag-of-Words mode freq (sparse)
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")
# Initialisation et entraînement du classifieur Naive Bayes
nb_classifier = classif.ClassifierNaiveBayesMultinomialBinary(input_dimension=len(index_mots), alpha=1.0)
start = time.time()
nb_classifier.train(X_train_sparse, y_train_bin)
end = time.time()
print("Temps d'entraînement:", end - start, "secondes")
# Prédictions
y_train_pred = nb_classifier.predict(X_train_sparse)
y_test_pred = nb_classifier.predict(X_test_sparse)
# Calcul des précisions
train_acc = (y_train_pred == y_train_bin).mean()
test_acc = (y_test_pred == y_test_bin).mean()
print("Accuracy finale (train):", train_acc)
print("Accuracy finale (test):", test_acc)
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(nb_classifier, (X_train_sparse, y_train_bin), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# Visualisation de la matrice de confusion
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[0,1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {classe1}", f"Classe {classe2}"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion - Naive Bayes avec BoW (freq)")
plt.show()
Temps d'entraînement: 0.00034308433532714844 secondes Accuracy finale (train): 0.9884393063583815 Accuracy finale (test): 0.8131377551020408 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5242 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5242 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5346 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5311 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5242 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.5242214532871973), np.float64(0.5242214532871973), np.float64(0.5346020761245674), np.float64(0.5311418685121108), np.float64(0.5242214532871973)] Taux moyen de bonne classification : 0.5277 Écart-type : 0.0044
# ======================================================
# Classification binaire avec TF-IDF avec Naive Bayes - Version 4
# ======================================================
# Sélection des classes
classe1 = 0
classe2 = 1
# Filtrage des données
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Conversion des labels en 0 et 1
df_binaire['target_bin'] = df_binaire['target'].apply(lambda x: 0 if x == classe1 else 1)
df_test_bin['target_bin'] = df_test_bin['target'].apply(lambda x: 0 if x == classe1 else 1)
y_train_bin = df_binaire['target_bin'].values
y_test_bin = df_test_bin['target_bin'].values
# Extraction des textes tokenisés
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation TF-IDF manuelle (avec la fonction fournie)
X_train_tfidf, vocab_index = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_tfidf, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
# Initialisation et entraînement du classifieur Naive Bayes
nb_classifier = classif.ClassifierNaiveBayesMultinomialBinary(input_dimension=len(index_mots), alpha=1.0)
start = time.time()
nb_classifier.train(X_train_tfidf, y_train_bin)
end = time.time()
print("Temps d'entraînement:", end - start, "secondes")
# Prédictions
y_train_pred = nb_classifier.predict(X_train_tfidf)
y_test_pred = nb_classifier.predict(X_test_tfidf)
# Calcul des précisions
train_acc = (y_train_pred == y_train_bin).mean()
test_acc = (y_test_pred == y_test_bin).mean()
print("Accuracy finale (train):", train_acc)
print("Accuracy finale (test):", test_acc)
# Validation croisée 5 folds sur l’ensemble d'entraînement binaire
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(nb_classifier, (X_train_tfidf, y_train_bin), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# Visualisation de la matrice de confusion
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[0,1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {classe1}", f"Classe {classe2}"])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion - Naive Bayes avec TF-IDF manuel")
plt.show()
Temps d'entraînement: 0.00033593177795410156 secondes Accuracy finale (train): 0.9884393063583815 Accuracy finale (test): 0.8679846938775511 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5104 Itération 1: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5208 Itération 2: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5311 Itération 3: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5138 Itération 4: taille base app.= 139 taille base test=34 Taux de bonne classif: 0.5208 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.5103806228373703), np.float64(0.5207612456747405), np.float64(0.5311418685121108), np.float64(0.513840830449827), np.float64(0.5207612456747405)] Taux moyen de bonne classification : 0.5194 Écart-type : 0.0071
# ======================================================
# Classification multiclasse avec Binary avec Naive Bayes - Version 1
# ======================================================
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train['target'].values
y_test_multi = df_test['target'].values
# Vectorisation avec Bag-of-Words mode binary (sparse)
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")
# Initialisation du classifieur binaire et du classifieur multi-classe
cl_bin = classif.ClassifierNaiveBayesMultinomialBinary(input_dimension=len(index_mots), alpha=1.0)
nb_classifier_multi = classif.ClassifierMultiOAA(cl_bin)
# Entraînement
start = time.time()
nb_classifier_multi.train(X_train_sparse, y_train_multi)
end = time.time()
print("Temps d'entraînement:", end - start, "secondes")
# Prédictions
y_train_pred = nb_classifier_multi.predict(X_train_sparse)
y_test_pred = nb_classifier_multi.predict(X_test_sparse)
# Calcul des précisions
train_acc = (y_train_pred == y_train_multi).mean()
test_acc = (y_test_pred == y_test_multi).mean()
print("Accuracy finale (train):", train_acc)
print("Accuracy finale (test):", test_acc)
# Validation croisée 5 folds sur l’ensemble d'entraînement multiclasse
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(nb_classifier_multi, (X_train_sparse, y_train_multi), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# Visualisation de la matrice de confusion
classes_uniques = np.unique(y_test_multi)
cm = confusion_matrix(y_test_multi, y_test_pred, labels=classes_uniques)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {c}" for c in classes_uniques])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion - Naive Bayes multiclasse avec binary")
plt.show()
Temps d'entraînement: 0.007356166839599609 secondes Accuracy finale (train): 0.8867102396514162 Accuracy finale (test): 0.4631990378833434 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0515 Itération 1: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0520 Itération 2: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0511 Itération 3: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0516 Itération 4: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0516 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.05145061728395062), np.float64(0.05201388888888889), np.float64(0.05114969135802469), np.float64(0.051604938271604936), np.float64(0.051604938271604936)] Taux moyen de bonne classification : 0.0516 Écart-type : 0.0003
# ======================================================
# Classification multiclasse avec Comptage avec Naive Bayes - Version 2
# ======================================================
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train['target'].values
y_test_multi = df_test['target'].values
# Vectorisation avec Bag-of-Words mode count (sparse)
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")
# Initialisation du classifieur binaire et du classifieur multi-classe
cl_bin = classif.ClassifierNaiveBayesMultinomialBinary(input_dimension=len(index_mots), alpha=1.0)
nb_classifier_multi = classif.ClassifierMultiOAA(cl_bin)
# Entraînement
start = time.time()
nb_classifier_multi.train(X_train_sparse, y_train_multi)
end = time.time()
print("Temps d'entraînement:", end - start, "secondes")
# Prédictions
y_train_pred = nb_classifier_multi.predict(X_train_sparse)
y_test_pred = nb_classifier_multi.predict(X_test_sparse)
# Calcul des précisions
train_acc = (y_train_pred == y_train_multi).mean()
test_acc = (y_test_pred == y_test_multi).mean()
print("Accuracy finale (train):", train_acc)
print("Accuracy finale (test):", test_acc)
# Validation croisée 5 folds sur l’ensemble d'entraînement multiclasse
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(nb_classifier_multi, (X_train_sparse, y_train_multi), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# Visualisation de la matrice de confusion
classes_uniques = np.unique(y_test_multi)
cm = confusion_matrix(y_test_multi, y_test_pred, labels=classes_uniques)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {c}" for c in classes_uniques])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion - Naive Bayes multiclasse avec count")
plt.show()
Temps d'entraînement: 0.0053441524505615234 secondes Accuracy finale (train): 0.829520697167756 Accuracy finale (test): 0.4488274203247144 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0504 Itération 1: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0517 Itération 2: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0502 Itération 3: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0507 Itération 4: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0507 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.05043981481481481), np.float64(0.0517283950617284), np.float64(0.05015432098765432), np.float64(0.05065586419753086), np.float64(0.050709876543209874)] Taux moyen de bonne classification : 0.0507 Écart-type : 0.0005
# ======================================================
# Classification multiclasse avec Frequence avec Naive Bayes - Version 3
# ======================================================
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train['target'].values
y_test_multi = df_test['target'].values
# Vectorisation avec Bag-of-Words mode count (sparse)
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")
# Initialisation du classifieur binaire et du classifieur multi-classe
cl_bin = classif.ClassifierNaiveBayesMultinomialBinary(input_dimension=len(index_mots), alpha=1.0)
nb_classifier_multi = classif.ClassifierMultiOAA(cl_bin)
# Entraînement
start = time.time()
nb_classifier_multi.train(X_train_sparse, y_train_multi)
end = time.time()
print("Temps d'entraînement:", end - start, "secondes")
# Prédictions
y_train_pred = nb_classifier_multi.predict(X_train_sparse)
y_test_pred = nb_classifier_multi.predict(X_test_sparse)
# Calcul des précisions
train_acc = (y_train_pred == y_train_multi).mean()
test_acc = (y_test_pred == y_test_multi).mean()
print("Accuracy finale (train):", train_acc)
print("Accuracy finale (test):", test_acc)
# Validation croisée 5 folds sur l’ensemble d'entraînement multiclasse
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(nb_classifier_multi, (X_train_sparse, y_train_multi), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# Visualisation de la matrice de confusion
classes_uniques = np.unique(y_test_multi)
cm = confusion_matrix(y_test_multi, y_test_pred, labels=classes_uniques)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {c}" for c in classes_uniques])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion - Naive Bayes multiclasse avec count")
plt.show()
Temps d'entraînement: 0.008103132247924805 secondes Accuracy finale (train): 0.789760348583878 Accuracy finale (test): 0.4141912206855081 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0522 Itération 1: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0522 Itération 2: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0520 Itération 3: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0522 Itération 4: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0522 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.052237654320987655), np.float64(0.052222222222222225), np.float64(0.05201388888888889), np.float64(0.052160493827160495), np.float64(0.05219907407407407)] Taux moyen de bonne classification : 0.0522 Écart-type : 0.0001
# ======================================================
# Classification multiclasse avec TF-IDF avec Naive Bayes - Version 4
# ======================================================
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train['target'].values
y_test_multi = df_test['target'].values
# Vectorisation TF-IDF manuelle (avec la fonction fournie)
X_train_tfidf, vocab_index = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_tfidf, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
# Initialisation du classifieur binaire et du classifieur multi-classe
cl_bin = classif.ClassifierNaiveBayesMultinomialBinary(input_dimension=len(index_mots), alpha=1.0)
nb_classifier_multi = classif.ClassifierMultiOAA(cl_bin)
# Entraînement
start = time.time()
nb_classifier_multi.train(X_train_tfidf, y_train_multi)
end = time.time()
print("Temps d'entraînement:", end - start, "secondes")
# Prédictions
y_train_pred = nb_classifier_multi.predict(X_train_tfidf)
y_test_pred = nb_classifier_multi.predict(X_test_tfidf)
# Calcul des précisions
train_acc = (y_train_pred == y_train_multi).mean()
test_acc = (y_test_pred == y_test_multi).mean()
print("Accuracy finale (train):", train_acc)
print("Accuracy finale (test):", test_acc)
# Validation croisée 5 folds sur l’ensemble d'entraînement multiclasse
nb_folds = 5
perf_fold, moyenne, ecart_type = ev.validation_croisee(nb_classifier_multi, (X_train_tfidf, y_train_multi), nb_folds)
print(f"Taux de bonne classification par fold : {perf_fold}")
print(f"Taux moyen de bonne classification : {moyenne:.4f}")
print(f"Écart-type : {ecart_type:.4f}")
# Visualisation de la matrice de confusion
classes_uniques = np.unique(y_test_multi)
cm = confusion_matrix(y_test_multi, y_test_pred, labels=classes_uniques)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {c}" for c in classes_uniques])
disp.plot(cmap='Blues')
plt.title("Matrice de confusion - Naive Bayes multiclasse avec TF-IDF")
plt.show()
Temps d'entraînement: 0.005766153335571289 secondes Accuracy finale (train): 0.9183006535947712 Accuracy finale (test): 0.49284425736620563 ------ affichage validation croisée (optionnel) Itération 0: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0520 Itération 1: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0520 Itération 2: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0518 Itération 3: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0518 Itération 4: taille base app.= 1476 taille base test=360 Taux de bonne classif: 0.0519 ------ fin affichage validation croisée Taux de bonne classification par fold : [np.float64(0.052021604938271605), np.float64(0.051959876543209875), np.float64(0.05184413580246913), np.float64(0.05183641975308642), np.float64(0.05189814814814815)] Taux moyen de bonne classification : 0.0519 Écart-type : 0.0001
Classifier Arbre de decision¶
# ======================================================
# Classification binaire avec Bag-of-Words (Binaire) avec Arbre de decision - Version 1
# ======================================================
# ---------------------------
# Paramètres
# ---------------------------
classe1 = 0
classe2 = 1
# Réduction de la taille pour accélérer les tests
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Préparation des données
df_binaire['target_bin'] = df_binaire['target']
df_test_bin['target_bin'] = df_test_bin['target']
y_train_bin = df_binaire['target_bin'].values
y_test_bin = df_test_bin['target_bin'].values
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="binary")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="binary")
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Utilisation de Scikit-learn pour l'arbre de décision
# ---------------------------
arbre_classifier = DecisionTreeClassifier(criterion="entropy", max_depth=3000, random_state=0)
# Entraînement
start = time.time()
arbre_classifier.fit(X_train, y_train_bin)
end = time.time()
print("Temps d'entraînement (Arbre de Décision - sklearn) :", end - start, "secondes")
# Prédictions
y_train_pred = arbre_classifier.predict(X_train)
y_test_pred = arbre_classifier.predict(X_test)
# Évaluation
acc_train = accuracy_score(y_train_bin, y_train_pred)
acc_test = accuracy_score(y_test_bin, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Validation croisée avec scoring accuracy
scores = cross_val_score(arbre_classifier, X_train, y_train_bin, cv=5, scoring='accuracy')
print(f"Taux de bonne classification par fold : {scores}")
print(f"Taux moyen de bonne classification : {scores.mean():.4f}")
print(f"Écart-type : {scores.std():.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[classe1, classe2])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {classe1}", f"Classe {classe2}"])
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Arbre de Décision (bag of words binary)")
plt.grid(False)
plt.tight_layout()
plt.show()
Temps d'entraînement (Arbre de Décision - sklearn) : 0.016485214233398438 secondes Accuracy entraînement : 0.9942 Accuracy test : 0.7838 Taux de bonne classification par fold : [0.68571429 0.85714286 0.68571429 0.76470588 0.67647059] Taux moyen de bonne classification : 0.7339 Écart-type : 0.0694
# ======================================================
# Classification binaire avec Bag-of-Words (Comptage) avec Arbre de decision - Version 2
# ======================================================
# ---------------------------
# Paramètres
# ---------------------------
classe1 = 0
classe2 = 1
# Réduction de la taille pour accélérer les tests
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Préparation des données
df_binaire['target_bin'] = df_binaire['target']
df_test_bin['target_bin'] = df_test_bin['target']
y_train_bin = df_binaire['target_bin'].values
y_test_bin = df_test_bin['target_bin'].values
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="count")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="count")
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Utilisation de Scikit-learn pour l'arbre de décision
# ---------------------------
arbre_classifier = DecisionTreeClassifier(criterion="entropy", max_depth=3000, random_state=0)
# Entraînement
start = time.time()
arbre_classifier.fit(X_train, y_train_bin)
end = time.time()
print("Temps d'entraînement (Arbre de Décision - sklearn) :", end - start, "secondes")
# Prédictions
y_train_pred = arbre_classifier.predict(X_train)
y_test_pred = arbre_classifier.predict(X_test)
# Évaluation
acc_train = accuracy_score(y_train_bin, y_train_pred)
acc_test = accuracy_score(y_test_bin, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Validation croisée avec scoring accuracy
scores = cross_val_score(arbre_classifier, X_train, y_train_bin, cv=5, scoring='accuracy')
print(f"Taux de bonne classification par fold : {scores}")
print(f"Taux moyen de bonne classification : {scores.mean():.4f}")
print(f"Écart-type : {scores.std():.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[classe1, classe2])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {classe1}", f"Classe {classe2}"])
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Arbre de Décision (bag of words comptage)")
plt.grid(False)
plt.tight_layout()
plt.show()
Temps d'entraînement (Arbre de Décision - sklearn) : 0.013701915740966797 secondes Accuracy entraînement : 0.9942 Accuracy test : 0.7838 Taux de bonne classification par fold : [0.68571429 0.85714286 0.71428571 0.76470588 0.67647059] Taux moyen de bonne classification : 0.7397 Écart-type : 0.0663
# ======================================================
# Classification binaire avec Bag-of-Words (Frequence) avec Arbre de decision - Version 3
# ======================================================
# ---------------------------
# Paramètres
# ---------------------------
classe1 = 0
classe2 = 1
# Réduction de la taille pour accélérer les tests
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Préparation des données
df_binaire['target_bin'] = df_binaire['target']
df_test_bin['target_bin'] = df_test_bin['target']
y_train_bin = df_binaire['target_bin'].values
y_test_bin = df_test_bin['target_bin'].values
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode="freq")
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode="freq")
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Utilisation de Scikit-learn pour l'arbre de décision
# ---------------------------
arbre_classifier = DecisionTreeClassifier(criterion="entropy", max_depth=3000, random_state=0)
# Entraînement
start = time.time()
arbre_classifier.fit(X_train, y_train_bin)
end = time.time()
print("Temps d'entraînement (Arbre de Décision - sklearn) :", end - start, "secondes")
# Prédictions
y_train_pred = arbre_classifier.predict(X_train)
y_test_pred = arbre_classifier.predict(X_test)
# Évaluation
acc_train = accuracy_score(y_train_bin, y_train_pred)
acc_test = accuracy_score(y_test_bin, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Validation croisée avec scoring accuracy
scores = cross_val_score(arbre_classifier, X_train, y_train_bin, cv=5, scoring='accuracy')
print(f"Taux de bonne classification par fold : {scores}")
print(f"Taux moyen de bonne classification : {scores.mean():.4f}")
print(f"Écart-type : {scores.std():.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[classe1, classe2])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {classe1}", f"Classe {classe2}"])
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Arbre de Décision (bag of words comptage)")
plt.grid(False)
plt.tight_layout()
plt.show()
Temps d'entraînement (Arbre de Décision - sklearn) : 0.014307022094726562 secondes Accuracy entraînement : 0.9942 Accuracy test : 0.7640 Taux de bonne classification par fold : [0.77142857 0.74285714 0.65714286 0.70588235 0.64705882] Taux moyen de bonne classification : 0.7049 Écart-type : 0.0479
# ======================================================
# Classification binaire avec Bag-of-Words (tf-idf) avec Arbre de decision - Version 4
# ======================================================
# ---------------------------
# Paramètres
# ---------------------------
classe1 = 0
classe2 = 1
# Réduction de la taille pour accélérer les tests (optionnel)
df_binaire = df_train[df_train['target'].isin([classe1, classe2])].copy()
df_test_bin = df_test[df_test['target'].isin([classe1, classe2])].copy()
# Labels
df_binaire['target_bin'] = df_binaire['target']
df_test_bin['target_bin'] = df_test_bin['target']
y_train_bin = df_binaire['target_bin'].values
y_test_bin = df_test_bin['target_bin'].values
texts_tokenized_train = df_binaire["les_mots"].tolist()
texts_tokenized_test = df_test_bin["les_mots"].tolist()
# ---------------------------
# TF-IDF Vectorisation (manuelle)
# ---------------------------
X_train_sparse, vocab_index = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Arbre de Décision (scikit-learn)
# ---------------------------
arbre_classifier = DecisionTreeClassifier(
criterion="entropy",
max_depth=3000,
class_weight="balanced",
random_state=0
)
# Entraînement
start = time.time()
arbre_classifier.fit(X_train, y_train_bin)
end = time.time()
print("Temps d'entraînement (Arbre de Décision - TF-IDF) :", end - start, "secondes")
# Prédictions
y_train_pred = arbre_classifier.predict(X_train)
y_test_pred = arbre_classifier.predict(X_test)
# Évaluation
acc_train = accuracy_score(y_train_bin, y_train_pred)
acc_test = accuracy_score(y_test_bin, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Validation croisée avec scoring accuracy
scores = cross_val_score(arbre_classifier, X_train, y_train_bin, cv=5, scoring='accuracy')
print(f"Taux de bonne classification par fold : {scores}")
print(f"Taux moyen de bonne classification : {scores.mean():.4f}")
print(f"Écart-type : {scores.std():.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_bin, y_test_pred, labels=[classe1, classe2])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[f"Classe {classe1}", f"Classe {classe2}"])
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Arbre de Décision (TF-IDF)")
plt.grid(False)
plt.tight_layout()
plt.show()
Temps d'entraînement (Arbre de Décision - TF-IDF) : 0.016049861907958984 secondes Accuracy entraînement : 0.9942 Accuracy test : 0.7615 Taux de bonne classification par fold : [0.77142857 0.74285714 0.57142857 0.73529412 0.61764706] Taux moyen de bonne classification : 0.6877 Écart-type : 0.0784
# ==========================================================
# Classification multi-classe avec Arbre de Décision (Bag-of-Words binary) - Version 1
# ==========================================================
# ---------------------------
# Paramètres
# ---------------------------
mode_vectorisation = "binary" # "binary", "count", "freq", "tfidf"
max_depth = 3000 # profondeur maximale de l’arbre
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle
# ---------------------------
# Initialisation du classifieur sklearn
tree_classifier = DecisionTreeClassifier(criterion="entropy", max_depth=max_depth, random_state=0)
# Chronométrage
start = time.time()
tree_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe - arbre de décision) :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = tree_classifier.predict(X_train)
y_test_pred = tree_classifier.predict(X_test)
# ---------------------------
# Évaluation des performances
# ---------------------------
# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Arbre de Décision (bag-of-words binary)")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sklearn)
# ---------------------------
cv = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=0)
scores = cross_val_score(tree_classifier, X_train, y_train_multi, cv=cv, scoring='accuracy')
print(f"Taux de bonne classification par fold : {scores}")
print(f"Taux moyen de bonne classification : {scores.mean():.4f}")
print(f"Écart-type : {scores.std():.4f}")
Temps d'entraînement (multi-classe - arbre de décision) : 1.058288335800171 secondes Accuracy entraînement : 0.9891 Accuracy test : 0.2162
Taux de bonne classification par fold : [0.20652174 0.1852861 0.21253406 0.20435967 0.20980926] Taux moyen de bonne classification : 0.2037 Écart-type : 0.0096
# ==========================================================
# Classification multi-classe avec Arbre de Décision (Bag-of-Words comptage) - Version 2
# ==========================================================
# ---------------------------
# Paramètres
# ---------------------------
mode_vectorisation = "count" # "binary", "count", "freq", "tfidf"
max_depth = 3000 # profondeur maximale de l’arbre
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle
# ---------------------------
# Initialisation du classifieur sklearn
tree_classifier = DecisionTreeClassifier(criterion="entropy", max_depth=max_depth, random_state=0)
# Chronométrage
start = time.time()
tree_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe - arbre de décision) :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = tree_classifier.predict(X_train)
y_test_pred = tree_classifier.predict(X_test)
# ---------------------------
# Évaluation des performances
# ---------------------------
# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Arbre de Décision (bag-of-words count)")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sklearn)
# ---------------------------
cv = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=0)
scores = cross_val_score(tree_classifier, X_train, y_train_multi, cv=cv, scoring='accuracy')
print(f"Taux de bonne classification par fold : {scores}")
print(f"Taux moyen de bonne classification : {scores.mean():.4f}")
print(f"Écart-type : {scores.std():.4f}")
Temps d'entraînement (multi-classe - arbre de décision) : 1.03580904006958 secondes Accuracy entraînement : 0.9891 Accuracy test : 0.2191
Taux de bonne classification par fold : [0.20380435 0.1880109 0.22343324 0.22615804 0.23705722] Taux moyen de bonne classification : 0.2157 Écart-type : 0.0175
# ==========================================================
# Classification multi-classe avec Arbre de Décision (Bag-of-Words frequence) - Version 3
# ==========================================================
# ---------------------------
# Paramètres
# ---------------------------
mode_vectorisation = "freq" # "binary", "count", "freq", "tfidf"
max_depth = 3000 # profondeur maximale de l’arbre
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation
X_train_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_train, index_mots, mode=mode_vectorisation)
X_test_sparse, _ = bag_of_words_sparse_manual(texts_tokenized_test, index_mots, mode=mode_vectorisation)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle
# ---------------------------
# Initialisation du classifieur sklearn
tree_classifier = DecisionTreeClassifier(criterion="entropy", max_depth=max_depth, random_state=0)
# Chronométrage
start = time.time()
tree_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe - arbre de décision) :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = tree_classifier.predict(X_train)
y_test_pred = tree_classifier.predict(X_test)
# ---------------------------
# Évaluation des performances
# ---------------------------
# Accuracy globale
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
# Matrice de confusion
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Arbre de Décision (bag-of-words count)")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sklearn)
# ---------------------------
cv = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=0)
scores = cross_val_score(tree_classifier, X_train, y_train_multi, cv=cv, scoring='accuracy')
print(f"Taux de bonne classification par fold : {scores}")
print(f"Taux moyen de bonne classification : {scores.mean():.4f}")
print(f"Écart-type : {scores.std():.4f}")
Temps d'entraînement (multi-classe - arbre de décision) : 1.2291460037231445 secondes Accuracy entraînement : 0.9891 Accuracy test : 0.2162
Taux de bonne classification par fold : [0.20652174 0.19618529 0.19618529 0.22070845 0.22615804] Taux moyen de bonne classification : 0.2092 Écart-type : 0.0124
# ==========================================================
# Classification multi-classe avec Arbre de Décision (TF-IDF avec bag_of_words_tfidf_manual) - Version 4
# ==========================================================
# ---------------------------
# Paramètres
# ---------------------------
max_depth = 3000
nb_folds = 5
# ---------------------------
# Préparation des données
# ---------------------------
# Extraction des textes tokenisés et des labels
texts_tokenized_train = df_train["les_mots"].tolist()
texts_tokenized_test = df_test["les_mots"].tolist()
y_train_multi = df_train["target"].values
y_test_multi = df_test["target"].values
# Vectorisation avec ta fonction TF-IDF
X_train_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_train, index_mots)
X_test_sparse, _ = bag_of_words_tfidf_manual(texts_tokenized_test, index_mots)
X_train = X_train_sparse.toarray()
X_test = X_test_sparse.toarray()
# ---------------------------
# Entraînement du modèle
# ---------------------------
tree_classifier = DecisionTreeClassifier(criterion="entropy", max_depth=max_depth, random_state=0)
start = time.time()
tree_classifier.fit(X_train, y_train_multi)
end = time.time()
print("Temps d'entraînement (multi-classe - arbre de décision) :", end - start, "secondes")
# ---------------------------
# Prédictions
# ---------------------------
y_train_pred = tree_classifier.predict(X_train)
y_test_pred = tree_classifier.predict(X_test)
# ---------------------------
# Évaluation des performances
# ---------------------------
acc_train = accuracy_score(y_train_multi, y_train_pred)
acc_test = accuracy_score(y_test_multi, y_test_pred)
print(f"Accuracy entraînement : {acc_train:.4f}")
print(f"Accuracy test : {acc_test:.4f}")
cm = confusion_matrix(y_test_multi, y_test_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot(cmap="Blues", xticks_rotation=90)
plt.title("Matrice de confusion - Arbre de Décision (TF-IDF manuel)")
plt.grid(False)
plt.tight_layout()
plt.show()
# ---------------------------
# Validation croisée (sklearn)
# ---------------------------
cv = StratifiedKFold(n_splits=nb_folds, shuffle=True, random_state=0)
scores = cross_val_score(tree_classifier, X_train, y_train_multi, cv=cv, scoring='accuracy')
print(f"Taux de bonne classification par fold : {scores}")
print(f"Taux moyen de bonne classification : {scores.mean():.4f}")
print(f"Écart-type : {scores.std():.4f}")
Temps d'entraînement (multi-classe - arbre de décision) : 1.1658222675323486 secondes Accuracy entraînement : 0.9891 Accuracy test : 0.2163
Taux de bonne classification par fold : [0.20652174 0.19618529 0.19618529 0.22070845 0.22615804] Taux moyen de bonne classification : 0.2092 Écart-type : 0.0124
Apprentissage non-supervisé¶
Tâche: vérifier que le découpage a du sens par rapport aux groupes fournis.
Etudes suggérées:
- étudier l'application d'un clustering hiérarchique et son résultat;
- étudier les résultats de l'application de l'algorithme des k-moyennes, pour différentes valeurs de k;
- proposer des évaluations des clusters trouvés afin de mettre en évidence les plus intéressants:
- en utilisant les indices d'évaluation présentés en cours;
- en comparant par diverses méthodes les clusters trouvés avec les vrais labels des classes (targets y).
- proposer une visualisation des résultats obtenus
Clustering hiérarchique¶
# Sélectionner les N premiers échantillons (par exemple 150)
N = 150
texts = newsgroups_df_neitoie['messages'][:N] # Prendre les 150 premiers messages
# Représentation par sac de mots (binary=True indique la présence/absence des mots)
vectorizer = CountVectorizer(binary=True)
X_small = vectorizer.fit_transform(texts).toarray() # Générer une matrice binaire de fréquence des mots
X_small_df = pd.DataFrame(X_small) # Convertir au format DataFrame
# Appel de l'algorithme de clustering hiérarchique CHA (avec différentes méthodes de liaison)
clust.CHA(X_small_df, linkage='centroid', verbose=False, dendrogramme=True) # Liaison par centroïde
clust.CHA(X_small_df, linkage='complete', verbose=False, dendrogramme=True) # Liaison complète
clust.CHA(X_small_df, linkage='average', verbose=False, dendrogramme=True) # Liaison moyenne
clust.CHA(X_small_df, linkage='simple', verbose=False, dendrogramme=True) # Liaison simple
[[53, 98, np.float64(3.4641016151377544), 2], [99, 150, np.float64(3.4641016151377544), 3], [11, 151, np.float64(3.605551275463989), 4], [80, 152, np.float64(3.7416573867739413), 5], [124, 153, np.float64(3.7416573867739413), 6], [14, 154, np.float64(3.872983346207417), 7], [144, 155, np.float64(3.872983346207417), 8], [146, 156, np.float64(3.872983346207417), 9], [73, 157, np.float64(4.0), 10], [88, 158, np.float64(4.123105625617661), 11], [133, 159, np.float64(4.242640687119285), 12], [117, 160, np.float64(4.358898943540674), 13], [47, 161, np.float64(4.47213595499958), 14], [43, 162, np.float64(4.69041575982343), 15], [68, 163, np.float64(4.898979485566356), 16], [127, 164, np.float64(5.0), 17], [71, 165, np.float64(5.0990195135927845), 18], [37, 166, np.float64(5.196152422706632), 19], [52, 167, np.float64(5.196152422706632), 20], [90, 168, np.float64(5.196152422706632), 21], [27, 169, np.float64(5.385164807134504), 22], [34, 170, np.float64(5.385164807134504), 23], [49, 171, np.float64(5.385164807134504), 24], [6, 172, np.float64(5.477225575051661), 25], [103, 173, np.float64(5.477225575051661), 26], [102, 174, np.float64(5.5677643628300215), 27], [31, 175, np.float64(5.656854249492381), 28], [69, 176, np.float64(5.656854249492381), 29], [32, 177, np.float64(5.744562646538029), 30], [84, 178, np.float64(5.744562646538029), 31], [147, 179, np.float64(5.830951894845301), 32], [10, 180, np.float64(5.916079783099616), 33], [25, 181, np.float64(6.0), 34], [33, 182, np.float64(6.0), 35], [135, 183, np.float64(6.0), 36], [106, 184, np.float64(6.082762530298219), 37], [100, 185, np.float64(6.244997998398398), 38], [104, 186, np.float64(6.244997998398398), 39], [129, 187, np.float64(6.244997998398398), 40], [140, 188, np.float64(6.244997998398398), 41], [35, 189, np.float64(6.324555320336759), 42], [66, 190, np.float64(6.324555320336759), 43], [76, 191, np.float64(6.4031242374328485), 44], [115, 192, np.float64(6.48074069840786), 45], [13, 193, np.float64(6.557438524302), 46], [41, 194, np.float64(6.6332495807108), 47], [83, 195, np.float64(6.6332495807108), 48], [62, 196, np.float64(6.708203932499369), 49], [65, 197, np.float64(6.708203932499369), 50], [1, 198, np.float64(6.782329983125268), 51], [36, 199, np.float64(6.782329983125268), 52], [58, 200, np.float64(6.782329983125268), 53], [143, 201, np.float64(6.855654600401044), 54], [9, 202, np.float64(6.928203230275509), 55], [21, 203, np.float64(6.928203230275509), 56], [8, 204, np.float64(7.0), 57], [107, 205, np.float64(7.0), 58], [142, 206, np.float64(7.0), 59], [97, 207, np.float64(7.0710678118654755), 60], [108, 208, np.float64(7.0710678118654755), 61], [123, 209, np.float64(7.211102550927978), 62], [81, 210, np.float64(7.280109889280518), 63], [50, 211, np.float64(7.3484692283495345), 64], [55, 212, np.float64(7.3484692283495345), 65], [5, 213, np.float64(7.483314773547883), 66], [67, 214, np.float64(7.483314773547883), 67], [116, 215, np.float64(7.54983443527075), 68], [111, 216, np.float64(7.615773105863909), 69], [145, 217, np.float64(7.681145747868608), 70], [77, 218, np.float64(7.745966692414834), 71], [92, 219, np.float64(7.745966692414834), 72], [17, 220, np.float64(7.810249675906654), 73], [149, 221, np.float64(7.810249675906654), 74], [85, 222, np.float64(7.937253933193772), 75], [114, 223, np.float64(8.0), 76], [148, 224, np.float64(8.0), 77], [122, 225, np.float64(8.06225774829855), 78], [125, 226, np.float64(8.12403840463596), 79], [138, 227, np.float64(8.12403840463596), 80], [39, 228, np.float64(8.306623862918075), 81], [4, 229, np.float64(8.366600265340756), 82], [51, 230, np.float64(8.426149773176359), 83], [78, 231, np.float64(8.426149773176359), 84], [82, 232, np.float64(8.54400374531753), 85], [3, 233, np.float64(8.660254037844387), 86], [23, 234, np.float64(8.660254037844387), 87], [130, 235, np.float64(8.660254037844387), 88], [131, 236, np.float64(8.660254037844387), 89], [46, 237, np.float64(8.717797887081348), 90], [16, 238, np.float64(8.774964387392123), 91], [79, 239, np.float64(8.774964387392123), 92], [137, 240, np.float64(8.888194417315589), 93], [128, 241, np.float64(8.94427190999916), 94], [57, 242, np.float64(9.1104335791443), 95], [40, 243, np.float64(9.16515138991168), 96], [60, 244, np.float64(9.219544457292887), 97], [45, 245, np.float64(9.273618495495704), 98], [95, 246, np.float64(9.327379053088816), 99], [132, 247, np.float64(9.327379053088816), 100], [0, 248, np.float64(9.38083151964686), 101], [126, 249, np.float64(9.433981132056603), 102], [134, 250, np.float64(9.433981132056603), 103], [101, 251, np.float64(9.486832980505138), 104], [15, 252, np.float64(9.539392014169456), 105], [96, 253, np.float64(9.695359714832659), 106], [22, 254, np.float64(9.746794344808963), 107], [26, 255, np.float64(9.746794344808963), 108], [74, 256, np.float64(9.848857801796104), 109], [64, 257, np.float64(9.899494936611665), 110], [7, 258, np.float64(9.9498743710662), 111], [30, 259, np.float64(9.9498743710662), 112], [72, 260, np.float64(10.04987562112089), 113], [105, 261, np.float64(10.198039027185569), 114], [139, 262, np.float64(10.295630140987), 115], [42, 263, np.float64(10.488088481701515), 116], [86, 264, np.float64(10.488088481701515), 117], [70, 265, np.float64(10.535653752852738), 118], [120, 266, np.float64(10.583005244258363), 119], [54, 267, np.float64(10.908712114635714), 120], [118, 268, np.float64(11.090536506409418), 121], [24, 269, np.float64(11.180339887498949), 122], [94, 270, np.float64(11.445523142259598), 123], [48, 271, np.float64(11.575836902790225), 124], [29, 272, np.float64(11.661903789690601), 125], [109, 273, np.float64(11.661903789690601), 126], [28, 274, np.float64(11.704699910719626), 127], [89, 275, np.float64(11.704699910719626), 128], [2, 276, np.float64(11.832159566199232), 129], [56, 277, np.float64(12.449899597988733), 130], [38, 278, np.float64(12.489995996796797), 131], [19, 279, np.float64(12.609520212918492), 132], [61, 280, np.float64(12.68857754044952), 133], [121, 281, np.float64(12.84523257866513), 134], [59, 282, np.float64(12.922847983320086), 135], [93, 283, np.float64(12.922847983320086), 136], [136, 284, np.float64(13.564659966250536), 137], [75, 285, np.float64(13.601470508735444), 138], [113, 286, np.float64(13.601470508735444), 139], [110, 287, np.float64(13.674794331177344), 140], [141, 288, np.float64(13.856406460551018), 141], [119, 289, np.float64(13.892443989449804), 142], [20, 290, np.float64(14.560219778561036), 143], [63, 291, np.float64(15.165750888103101), 144], [18, 292, np.float64(18.083141320025124), 145], [87, 293, np.float64(18.110770276274835), 146], [91, 294, np.float64(18.33030277982336), 147], [12, 295, np.float64(23.0), 148], [112, 296, np.float64(23.065125189341593), 149], [44, 297, np.float64(26.570660511172846), 150]]
k-moyennes¶
# Prendre tous les textes
texts = newsgroups_df_neitoie['messages']
# Ne pas limiter la taille du vocabulaire (peut avoir beaucoup de dimensions)
vectorizer = CountVectorizer(binary=True)
X_sparse = vectorizer.fit_transform(texts) # Le résultat est une matrice creuse
# Ici, il faut absolument convertir en dense pour faire l'ACP
X_dense = X_sparse.toarray()
# ACP pour réduire à deux dimensions
X_pca = PCA(n_components=2).fit_transform(X_dense)
# Convertir en DataFrame pour la visualisation
X_df = pd.DataFrame(X_pca, columns=["PC1", "PC2"])
# Définition des paramètres
K = 5 # Nombre de clusters
epsilon = 1e-4 # Seuil de convergence
iter_max = 50 # Nombre maximum d'itérations
# Exécution de l’algorithme k-means
centroids, affectation = clust.kmoyennes(K, X_df, epsilon, iter_max)
clust.affiche_resultat(X_df, centroids, affectation)
Iteration 1 Inertie : 46403.0196 Difference: 46402.0195 Iteration 2 Inertie : 39415.0931 Difference: 6987.9265 Iteration 3 Inertie : 35396.8007 Difference: 4018.2924 Iteration 4 Inertie : 32709.2515 Difference: 2687.5492 Iteration 5 Inertie : 30796.1320 Difference: 1913.1195 Iteration 6 Inertie : 29434.1439 Difference: 1361.9881 Iteration 7 Inertie : 28252.3214 Difference: 1181.8225 Iteration 8 Inertie : 27136.2536 Difference: 1116.0679 Iteration 9 Inertie : 26075.2361 Difference: 1061.0174 Iteration 10 Inertie : 25061.4848 Difference: 1013.7513 Iteration 11 Inertie : 24212.7577 Difference: 848.7271 Iteration 12 Inertie : 23615.9200 Difference: 596.8377 Iteration 13 Inertie : 23094.4398 Difference: 521.4802 Iteration 14 Inertie : 22589.7039 Difference: 504.7359 Iteration 15 Inertie : 22034.8734 Difference: 554.8305 Iteration 16 Inertie : 21549.7585 Difference: 485.1149 Iteration 17 Inertie : 21180.6042 Difference: 369.1543 Iteration 18 Inertie : 20858.2281 Difference: 322.3761 Iteration 19 Inertie : 20599.0363 Difference: 259.1917 Iteration 20 Inertie : 20403.3282 Difference: 195.7081 Iteration 21 Inertie : 20212.9472 Difference: 190.3810 Iteration 22 Inertie : 20036.0589 Difference: 176.8882 Iteration 23 Inertie : 19870.5194 Difference: 165.5395 Iteration 24 Inertie : 19742.1745 Difference: 128.3448 Iteration 25 Inertie : 19672.7197 Difference: 69.4548 Iteration 26 Inertie : 19610.7459 Difference: 61.9738 Iteration 27 Inertie : 19548.1759 Difference: 62.5700 Iteration 28 Inertie : 19508.2479 Difference: 39.9280 Iteration 29 Inertie : 19482.1350 Difference: 26.1129 Iteration 30 Inertie : 19458.5418 Difference: 23.5932 Iteration 31 Inertie : 19442.3436 Difference: 16.1982 Iteration 32 Inertie : 19430.7375 Difference: 11.6061 Iteration 33 Inertie : 19422.0440 Difference: 8.6935 Iteration 34 Inertie : 19414.0890 Difference: 7.9550 Iteration 35 Inertie : 19408.4960 Difference: 5.5930 Iteration 36 Inertie : 19402.8801 Difference: 5.6159 Iteration 37 Inertie : 19397.9217 Difference: 4.9583 Iteration 38 Inertie : 19393.6655 Difference: 4.2563 Iteration 39 Inertie : 19388.9800 Difference: 4.6855 Iteration 40 Inertie : 19386.1392 Difference: 2.8408 Iteration 41 Inertie : 19384.1877 Difference: 1.9515 Iteration 42 Inertie : 19383.1464 Difference: 1.0413 Iteration 43 Inertie : 19382.0251 Difference: 1.1213 Iteration 44 Inertie : 19381.0180 Difference: 1.0071 Iteration 45 Inertie : 19380.2422 Difference: 0.7759 Iteration 46 Inertie : 19379.7329 Difference: 0.5093 Iteration 47 Inertie : 19379.1265 Difference: 0.6064 Iteration 48 Inertie : 19378.7395 Difference: 0.3870 Iteration 49 Inertie : 19378.4130 Difference: 0.3265 Iteration 50 Inertie : 19378.0378 Difference: 0.3752
# Restaurer l'identifiant de cluster pour chaque échantillon sous forme de tableau
labels = np.zeros(len(X_df))
for cluster_id, indices in affectation.items():
labels[indices] = cluster_id
# Calcul du score de silhouette
score = silhouette_score(X_df.values, labels)
print(f"Score de silhouette : {score:.4f}")
Score de silhouette : 0.4846
X_np = X_df.to_numpy()
labels = labels.astype(int)
xb = ev.xie_beni_index_manual(X_np, labels, centroids)
dunn = ev.dunn_index_manual(X_np, labels)
print(f"Xie-Beni Index (manual): {xb:.4f}")
print(f"Dunn Index (manual): {dunn:.4f}")
Xie-Beni Index (manual): 0.3101 Dunn Index (manual): 0.0001
y_true = newsgroups_df_neitoie['target'].values
labels_small = labels # labels doit déjà contenir 1000 éléments
# Comparaison
ari = adjusted_rand_score(y_true, labels_small)
nmi = normalized_mutual_info_score(y_true, labels_small)
print(f"Indice de Rand Ajusté (ARI) : {ari:.4f}")
print(f"Information Mutuelle Normalisée (NMI) : {nmi:.4f}")
Indice de Rand Ajusté (ARI) : 0.0064 Information Mutuelle Normalisée (NMI) : 0.0242
# Définition des paramètres
K = 10 # Nombre de clusters
epsilon = 1e-4 # Seuil de convergence
iter_max = 50 # Nombre maximum d'itérations
# Exécution de l’algorithme k-means
centroids, affectation = clust.kmoyennes(K, X_df, epsilon, iter_max)
clust.affiche_resultat(X_df, centroids, affectation)
Iteration 1 Inertie : 55577.3123 Difference: 55576.3122 Iteration 2 Inertie : 43883.8869 Difference: 11693.4253 Iteration 3 Inertie : 37393.1439 Difference: 6490.7431 Iteration 4 Inertie : 33005.3924 Difference: 4387.7514 Iteration 5 Inertie : 28830.9562 Difference: 4174.4362 Iteration 6 Inertie : 20159.4831 Difference: 8671.4731 Iteration 7 Inertie : 15741.6647 Difference: 4417.8184 Iteration 8 Inertie : 14822.3822 Difference: 919.2825 Iteration 9 Inertie : 14283.3197 Difference: 539.0625 Iteration 10 Inertie : 13835.0995 Difference: 448.2202 Iteration 11 Inertie : 13470.6912 Difference: 364.4083 Iteration 12 Inertie : 13150.6046 Difference: 320.0866 Iteration 13 Inertie : 12901.8988 Difference: 248.7058 Iteration 14 Inertie : 12705.3962 Difference: 196.5025 Iteration 15 Inertie : 12526.0723 Difference: 179.3240 Iteration 16 Inertie : 12372.7408 Difference: 153.3314 Iteration 17 Inertie : 12234.2950 Difference: 138.4459 Iteration 18 Inertie : 12101.3767 Difference: 132.9183 Iteration 19 Inertie : 11973.2624 Difference: 128.1143 Iteration 20 Inertie : 11844.0723 Difference: 129.1901 Iteration 21 Inertie : 11725.9622 Difference: 118.1101 Iteration 22 Inertie : 11625.2652 Difference: 100.6970 Iteration 23 Inertie : 11517.0740 Difference: 108.1912 Iteration 24 Inertie : 11429.0055 Difference: 88.0684 Iteration 25 Inertie : 11341.3656 Difference: 87.6399 Iteration 26 Inertie : 11263.5221 Difference: 77.8435 Iteration 27 Inertie : 11186.5900 Difference: 76.9321 Iteration 28 Inertie : 11104.0295 Difference: 82.5605 Iteration 29 Inertie : 11018.5380 Difference: 85.4916 Iteration 30 Inertie : 10924.8554 Difference: 93.6826 Iteration 31 Inertie : 10789.4997 Difference: 135.3556 Iteration 32 Inertie : 10652.2133 Difference: 137.2865 Iteration 33 Inertie : 10536.6054 Difference: 115.6079 Iteration 34 Inertie : 10448.5441 Difference: 88.0613 Iteration 35 Inertie : 10379.3456 Difference: 69.1985 Iteration 36 Inertie : 10318.1563 Difference: 61.1893 Iteration 37 Inertie : 10266.6606 Difference: 51.4957 Iteration 38 Inertie : 10209.2166 Difference: 57.4440 Iteration 39 Inertie : 10158.2428 Difference: 50.9738 Iteration 40 Inertie : 10113.8277 Difference: 44.4152 Iteration 41 Inertie : 10081.0289 Difference: 32.7988 Iteration 42 Inertie : 10049.4325 Difference: 31.5964 Iteration 43 Inertie : 10020.2988 Difference: 29.1337 Iteration 44 Inertie : 9992.7377 Difference: 27.5611 Iteration 45 Inertie : 9963.4979 Difference: 29.2398 Iteration 46 Inertie : 9940.9922 Difference: 22.5057 Iteration 47 Inertie : 9918.3313 Difference: 22.6609 Iteration 48 Inertie : 9897.2770 Difference: 21.0542 Iteration 49 Inertie : 9877.3675 Difference: 19.9095 Iteration 50 Inertie : 9858.7481 Difference: 18.6194
# Restaurer l'identifiant de cluster pour chaque échantillon sous forme de tableau
labels = np.zeros(len(X_df))
for cluster_id, indices in affectation.items():
labels[indices] = cluster_id
# Calcul du score de silhouette
score = silhouette_score(X_df.values, labels)
print(f"Score de silhouette : {score:.4f}")
Score de silhouette : 0.4010
X_np = X_df.to_numpy()
labels = labels.astype(int)
xb = ev.xie_beni_index_manual(X_np, labels, centroids)
dunn = ev.dunn_index_manual(X_np, labels)
print(f"Xie-Beni Index (manual): {xb:.4f}")
print(f"Dunn Index (manual): {dunn:.4f}")
Xie-Beni Index (manual): 0.7242 Dunn Index (manual): 0.0000
y_true = newsgroups_df_neitoie['target'].values
labels_small = labels # labels doit déjà contenir 1000 éléments
# Comparaison
ari = adjusted_rand_score(y_true, labels_small)
nmi = normalized_mutual_info_score(y_true, labels_small)
print(f"Indice de Rand Ajusté (ARI) : {ari:.4f}")
print(f"Information Mutuelle Normalisée (NMI) : {nmi:.4f}")
Indice de Rand Ajusté (ARI) : 0.0065 Information Mutuelle Normalisée (NMI) : 0.0272
# Définition des paramètres
K = 20 # Nombre de clusters
epsilon = 1e-4 # Seuil de convergence
iter_max = 50 # Nombre maximum d'itérations
# Exécution de l’algorithme k-means
centroids, affectation = clust.kmoyennes(K, X_df, epsilon, iter_max)
clust.affiche_resultat(X_df, centroids, affectation)
Iteration 1 Inertie : 27268.6384 Difference: 27267.6383 Iteration 2 Inertie : 15995.3680 Difference: 11273.2704 Iteration 3 Inertie : 12129.4853 Difference: 3865.8827 Iteration 4 Inertie : 10412.0267 Difference: 1717.4586 Iteration 5 Inertie : 9309.5711 Difference: 1102.4556 Iteration 6 Inertie : 8709.7739 Difference: 599.7972 Iteration 7 Inertie : 8370.7626 Difference: 339.0113 Iteration 8 Inertie : 8121.1686 Difference: 249.5939 Iteration 9 Inertie : 7883.7018 Difference: 237.4669 Iteration 10 Inertie : 7679.6191 Difference: 204.0827 Iteration 11 Inertie : 7529.8441 Difference: 149.7750 Iteration 12 Inertie : 7412.1114 Difference: 117.7326 Iteration 13 Inertie : 7259.3056 Difference: 152.8058 Iteration 14 Inertie : 7163.7822 Difference: 95.5234 Iteration 15 Inertie : 7079.1300 Difference: 84.6522 Iteration 16 Inertie : 6971.2163 Difference: 107.9137 Iteration 17 Inertie : 6874.1317 Difference: 97.0846 Iteration 18 Inertie : 6788.2702 Difference: 85.8614 Iteration 19 Inertie : 6723.6032 Difference: 64.6671 Iteration 20 Inertie : 6676.2142 Difference: 47.3890 Iteration 21 Inertie : 6632.0965 Difference: 44.1177 Iteration 22 Inertie : 6583.2953 Difference: 48.8012 Iteration 23 Inertie : 6517.0966 Difference: 66.1988 Iteration 24 Inertie : 6468.9764 Difference: 48.1202 Iteration 25 Inertie : 6420.5834 Difference: 48.3929 Iteration 26 Inertie : 6360.8335 Difference: 59.7500 Iteration 27 Inertie : 6294.8602 Difference: 65.9733 Iteration 28 Inertie : 6221.9922 Difference: 72.8680 Iteration 29 Inertie : 6121.3740 Difference: 100.6182 Iteration 30 Inertie : 6017.5421 Difference: 103.8318 Iteration 31 Inertie : 5909.1630 Difference: 108.3792 Iteration 32 Inertie : 5798.9171 Difference: 110.2459 Iteration 33 Inertie : 5705.9492 Difference: 92.9679 Iteration 34 Inertie : 5633.3364 Difference: 72.6128 Iteration 35 Inertie : 5568.9276 Difference: 64.4088 Iteration 36 Inertie : 5510.6744 Difference: 58.2532 Iteration 37 Inertie : 5463.3961 Difference: 47.2783 Iteration 38 Inertie : 5423.2500 Difference: 40.1461 Iteration 39 Inertie : 5387.0285 Difference: 36.2215 Iteration 40 Inertie : 5354.6471 Difference: 32.3814 Iteration 41 Inertie : 5323.0041 Difference: 31.6430 Iteration 42 Inertie : 5296.4243 Difference: 26.5798 Iteration 43 Inertie : 5274.3916 Difference: 22.0326 Iteration 44 Inertie : 5253.7765 Difference: 20.6152 Iteration 45 Inertie : 5240.3153 Difference: 13.4612 Iteration 46 Inertie : 5228.3164 Difference: 11.9989 Iteration 47 Inertie : 5217.9474 Difference: 10.3689 Iteration 48 Inertie : 5207.8680 Difference: 10.0795 Iteration 49 Inertie : 5198.6711 Difference: 9.1969 Iteration 50 Inertie : 5189.6008 Difference: 9.0703
# Restaurer l'identifiant de cluster pour chaque échantillon sous forme de tableau
labels = np.zeros(len(X_df))
for cluster_id, indices in affectation.items():
labels[indices] = cluster_id
# Calcul du score de silhouette
score = silhouette_score(X_df.values, labels)
print(f"Score de silhouette : {score:.4f}")
Score de silhouette : 0.3523
X_np = X_df.to_numpy()
labels = labels.astype(int)
xb = ev.xie_beni_index_manual(X_np, labels, centroids)
dunn = ev.dunn_index_manual(X_np, labels)
print(f"Xie-Beni Index (manual): {xb:.4f}")
print(f"Dunn Index (manual): {dunn:.4f}")
Xie-Beni Index (manual): 1.2682 Dunn Index (manual): 0.0001
y_true = newsgroups_df_neitoie['target'].values
labels_small = labels # labels doit déjà contenir 1000 éléments
# Comparaison
ari = adjusted_rand_score(y_true, labels_small)
nmi = normalized_mutual_info_score(y_true, labels_small)
print(f"Indice de Rand Ajusté (ARI) : {ari:.4f}")
print(f"Information Mutuelle Normalisée (NMI) : {nmi:.4f}")
Indice de Rand Ajusté (ARI) : 0.0063 Information Mutuelle Normalisée (NMI) : 0.0342
Poster à rendre dans le compte-rendu (format PDF)¶
Votre poster doit décrire de façon synthétique l'ensemble des expérimentations menées sur les données, les résultats obtenus en apprentissage supervisé et en apprentissage non-supervisé ainsi que les conclusions/bilans que vous tirez de ces expérimentations (ie. ce que vous avez appris sur ces données).
Remarque: vous devez indiquer vos noms/prénoms et groupe (1, 2, ou 3) sur le poster.